y_hooks 2

/*----------------------------------------------------------------------------*-
                    ==============================
                     y_hooks - Hook any callback!
                    ==============================
Description:
    Automatically hooks any callbacks with a very simple syntax.
Legal:
    Version: MPL 1.1

    The contents of this file are subject to the Mozilla Public License Version
    1.1 (the "License"); you may not use this file except in compliance with
    the License. You may obtain a copy of the License at
    http://www.mozilla.org/MPL/

    Software distributed under the License is distributed on an "AS IS" basis,
    WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
    for the specific language governing rights and limitations under the
    License.

    The Original Code is the SA:MP script information include.

    The Initial Developer of the Original Code is Alex "Y_Less" Cole.
    Portions created by the Initial Developer are Copyright (C) 2008
    the Initial Developer. All Rights Reserved.

    Contributors:
        ZeeX, koolk, JoeBullet/Google63, g_aSlice/Slice

    Thanks:
        JoeBullet/Google63 - Handy arbitrary ASM jump code using SCTRL.
        Peter, Cam - Support.
        ZeeX, g_aSlice/Slice, Popz, others - Very productive conversations.
        koolk - IsPlayerinAreaEx code.
        TheAlpha - Danish translation.
        breadfish - German translation.
        Fireburn - Dutch translation.
        yom - French translation.
        50p - Polish translation.
        Zamaroht - Spanish translation.
        Dracoblue, sintax, mabako, Xtreme, other coders - Producing other modes
            for me to strive to better.
        Pixels^ - Running XScripters where the idea was born.
        Matite - Pestering me to release it and using it.

    Very special thanks to:
        Thiadmer - PAWN, whose limits continue to amaze me!
        Kye/Kalcor - SA:MP.
        SA:MP Team past, present and future - SA:MP.

Version:
    1.0
Changelog:
    17/03/11:
        Second complete re-write using another new technique.  Now VERY fast!
        Updated OnPlayerUpdate code using Google63's SCTRL jump code.
    06/08/10:
        First version
-*----------------------------------------------------------------------------*/

#undef _inc_y_hooks

// Multiple includes!
#include <YSI\internal\y_unique>

#if defined _INC_y_hooks
    #endinput
#endif
// Everything except including "y_unique" is done once only.
#define _INC_y_hooks

#include <YSI\internal\y_version>
#include <a_samp>

#include <YSI\y_amx>

#define ALS_PREFIX S@@

#include <YSI\y_als>

#include <YSI\internal\y_defines>
#include <YSI\internal\y_scriptinit>

#define hook%0On%1(%2) UNIQUE_FUNCTION(@yH_%1,)(%2);public UNIQUE_FUNCTION(@yH_%1,)(%2)
#define Hook:%0On%1(%2) UNIQUE_FUNCTION(@yH_%1,%0)(%2);public UNIQUE_FUNCTION(@yH_%1,%0)(%2)
//hook OnPlayerConnect

ALS_DATA<>

enum E_FUNC_HOOK_DATA
{
    E_FUNC_HOOK_DATA_START,
    E_FUNC_HOOK_DATA_END
}

static stock
    YSI_g_sCallbackAddresses[HOOKS_MAX_UPDATES * _:ALS],
    YSI_g_sCallbackData[ALS][E_FUNC_HOOK_DATA],
    YSI_g_sLastFoundIndex;

static stock Hooks_RedirectPublic(from[], to[])
{
    new
        addr;
    if (AMX_GetPublicEntry(0, addr, from))
    {
        new
            pointer;
        if (AMX_GetPublicPointer(0, pointer, to))
        {
            AMX_Write(addr, pointer);
        }
    }
}

static Hooks_AddOne(idx, &toaddidx, struc[E_FUNC_HOOK_DATA])
{
    // This is a combination between the count and the end point.
    ++struc[E_FUNC_HOOK_DATA_END];
    if (toaddidx == sizeof (YSI_g_sCallbackAddresses))
    {
        if (struc[E_FUNC_HOOK_DATA_START] != sizeof (YSI_g_sCallbackAddresses))
        {
            YSI_g_sLastFoundIndex = idx;
        }
    }
    else
    {
        new
            addr = (idx - 1) * 8 + AMX_Header[AMX_HEADER_PUBLICS];
        #emit LREF.S.pri addr
        #emit STOR.S.pri addr
        YSI_g_sCallbackAddresses[toaddidx++] = addr;
    }
}

static Hooks_FindAll(name[], &toaddidx, struc[E_FUNC_HOOK_DATA], &count)
{
    new
        buffer[32],
        len = strlen(name);
    struc[E_FUNC_HOOK_DATA_START] = toaddidx;
    struc[E_FUNC_HOOK_DATA_END] = toaddidx;
    for (new idx; (idx = AMX_GetPublicNamePrefix(idx, buffer, _A<@yH_>)); )
    {
        if (!strcmp(name, buffer[1], false, len))
        {
            Hooks_AddOne(idx, toaddidx, struc);
        }
    }
    if (struc[E_FUNC_HOOK_DATA_START] < sizeof (YSI_g_sCallbackAddresses) && struc[E_FUNC_HOOK_DATA_END] >= sizeof (YSI_g_sCallbackAddresses))
    {
        printf("*** Internal warning: y_hooks buffer exhausted, resorting to slow method.");
    }
    count = struc[E_FUNC_HOOK_DATA_END] - struc[E_FUNC_HOOK_DATA_START];
    // Don't store the end, if the count goes off the end of the addresses array
    // then we need to just start reading from the AMX directly.
}

#define HOOKS_DO_ONE_CALLBACK<%0> ALS_DETECT<%0>Hooks_FindAll(#%0,cidx,YSI_g_sCallbackData[ALS_On%0],count);if(!count)Hooks_RedirectPublic(#On%0,#S@@_On%0);

public OnScriptInit()
{
    new
        cidx,
        count;
    HOOKS_DO_ONE_CALLBACK<ScriptInit>
    HOOKS_DO_ONE_CALLBACK<GameModeInit>
    HOOKS_DO_ONE_CALLBACK<GameModeExit>
    HOOKS_DO_ONE_CALLBACK<FilterScriptInit>
    HOOKS_DO_ONE_CALLBACK<FilterScriptExit>
    HOOKS_DO_ONE_CALLBACK<PlayerConnect>
    HOOKS_DO_ONE_CALLBACK<PlayerDisconnect>
    HOOKS_DO_ONE_CALLBACK<PlayerSpawn>
    HOOKS_DO_ONE_CALLBACK<PlayerDeath>
    HOOKS_DO_ONE_CALLBACK<VehicleSpawn>
    HOOKS_DO_ONE_CALLBACK<VehicleDeath>
    HOOKS_DO_ONE_CALLBACK<PlayerText>
    HOOKS_DO_ONE_CALLBACK<PlayerCommandText>
    HOOKS_DO_ONE_CALLBACK<PlayerRequestClass>
    HOOKS_DO_ONE_CALLBACK<PlayerEnterVehicle>
    HOOKS_DO_ONE_CALLBACK<PlayerExitVehicle>
    HOOKS_DO_ONE_CALLBACK<PlayerStateChange>
    HOOKS_DO_ONE_CALLBACK<PlayerEnterCheckpoint>
    HOOKS_DO_ONE_CALLBACK<PlayerLeaveCheckpoint>
    HOOKS_DO_ONE_CALLBACK<PlayerEnterRaceCheckpoint>
    HOOKS_DO_ONE_CALLBACK<PlayerLeaveRaceCheckpoint>
    HOOKS_DO_ONE_CALLBACK<RconCommand>
    HOOKS_DO_ONE_CALLBACK<PlayerRequestSpawn>
    HOOKS_DO_ONE_CALLBACK<ObjectMoved>
    HOOKS_DO_ONE_CALLBACK<PlayerObjectMoved>
    HOOKS_DO_ONE_CALLBACK<PlayerPickUpPickup>
    HOOKS_DO_ONE_CALLBACK<VehicleMod>
    HOOKS_DO_ONE_CALLBACK<EnterExitModShop>
    HOOKS_DO_ONE_CALLBACK<VehiclePaintjob>
    HOOKS_DO_ONE_CALLBACK<VehicleRespray>
    HOOKS_DO_ONE_CALLBACK<VehicleDamageStatusUpdate>
    HOOKS_DO_ONE_CALLBACK<PlayerSelectedMenuRow>
    HOOKS_DO_ONE_CALLBACK<PlayerExitedMenu>
    HOOKS_DO_ONE_CALLBACK<PlayerInteriorChange>
    HOOKS_DO_ONE_CALLBACK<PlayerKeyStateChange>
    HOOKS_DO_ONE_CALLBACK<RconLoginAttempt>
    HOOKS_DO_ONE_CALLBACK<PlayerUpdate>
    HOOKS_DO_ONE_CALLBACK<PlayerStreamIn>
    HOOKS_DO_ONE_CALLBACK<PlayerStreamOut>
    HOOKS_DO_ONE_CALLBACK<VehicleStreamIn>
    HOOKS_DO_ONE_CALLBACK<VehicleStreamOut>
    HOOKS_DO_ONE_CALLBACK<DialogResponse>
    HOOKS_DO_ONE_CALLBACK<PlayerClickPlayer>
    HOOKS_DO_ONE_CALLBACK<PlayerLogin>
    HOOKS_DO_ONE_CALLBACK<PlayerLogout>
    new
        end   = YSI_g_sCallbackData[ALS_OnScriptInit][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnScriptInit][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<ScriptInit>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_ScriptInit");
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<ScriptInit>
}
#undef OnScriptInit
#define OnScriptInit Command_OnScriptInit
forward OnScriptInit();

public OnGameModeInit()
{
    new
        end   = YSI_g_sCallbackData[ALS_OnGameModeInit][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnGameModeInit][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<GameModeInit>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_GameModeInit");
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<GameModeInit>
}
#if defined _ALS_OnGameModeInit
    #undef OnGameModeInit
#else
    #define _ALS_OnGameModeInit
#endif
#define OnGameModeInit S@@_OnGameModeInit
ALS_FORWARD<GameModeInit>

public OnGameModeExit()
{
    new
        end   = YSI_g_sCallbackData[ALS_OnGameModeExit][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnGameModeExit][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<GameModeExit>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_GameModeExit");
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<GameModeExit>
}
#if defined _ALS_OnGameModeExit
    #undef OnGameModeExit
#else
    #define _ALS_OnGameModeExit
#endif
#define OnGameModeExit S@@_OnGameModeExit
ALS_FORWARD<GameModeExit>

public OnFilterScriptInit()
{
    new
        end   = YSI_g_sCallbackData[ALS_OnFilterScriptInit][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnFilterScriptInit][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<FilterScriptInit>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_FilterScriptInit");
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<FilterScriptInit>
}
#if defined _ALS_OnFilterScriptInit
    #undef OnFilterScriptInit
#else
    #define _ALS_OnFilterScriptInit
#endif
#define OnFilterScriptInit S@@_OnFilterScriptInit
ALS_FORWARD<FilterScriptInit>

public OnFilterScriptExit()
{
    new
        end   = YSI_g_sCallbackData[ALS_OnFilterScriptExit][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnFilterScriptExit][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<FilterScriptExit>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_FilterScriptExit");
        #emit PUSH.C     0
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<FilterScriptExit>
}
#if defined _ALS_OnFilterScriptExit
    #undef OnFilterScriptExit
#else
    #define _ALS_OnFilterScriptExit
#endif
#define OnFilterScriptExit S@@_OnFilterScriptExit
ALS_FORWARD<FilterScriptExit>

public OnPlayerConnect(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerConnect][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerConnect][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerConnect>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerConnect");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerConnect>
}
#if defined _ALS_OnPlayerConnect
    #undef OnPlayerConnect
#else
    #define _ALS_OnPlayerConnect
#endif
#define OnPlayerConnect S@@_OnPlayerConnect
ALS_FORWARD<PlayerConnect>

public OnPlayerDisconnect(playerid, reason)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerDisconnect][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerDisconnect][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerDisconnect>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S reason
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerDisconnect");
        #emit PUSH.S reason
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerDisconnect>
}
#if defined _ALS_OnPlayerDisconnect
    #undef OnPlayerDisconnect
#else
    #define _ALS_OnPlayerDisconnect
#endif
#define OnPlayerDisconnect S@@_OnPlayerDisconnect
ALS_FORWARD<PlayerDisconnect>

public OnPlayerSpawn(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerSpawn][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerSpawn][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerSpawn>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerSpawn");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerSpawn>
}
#if defined _ALS_OnPlayerSpawn
    #undef OnPlayerSpawn
#else
    #define _ALS_OnPlayerSpawn
#endif
#define OnPlayerSpawn S@@_OnPlayerSpawn
ALS_FORWARD<PlayerSpawn>

public OnPlayerDeath(playerid, killerid, reason)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerDeath][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerDeath][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerDeath>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S reason
        #emit PUSH.S killerid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerDeath");
        #emit PUSH.S reason
        #emit PUSH.S killerid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerDeath>
}
#if defined _ALS_OnPlayerDeath
    #undef OnPlayerDeath
#else
    #define _ALS_OnPlayerDeath
#endif
#define OnPlayerDeath S@@_OnPlayerDeath
ALS_FORWARD<PlayerDeath>

public OnVehicleSpawn(vehicleid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnVehicleSpawn][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnVehicleSpawn][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<VehicleSpawn>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S vehicleid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_VehicleSpawn");
        #emit PUSH.S vehicleid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<VehicleSpawn>
}
#if defined _ALS_OnVehicleSpawn
    #undef OnVehicleSpawn
#else
    #define _ALS_OnVehicleSpawn
#endif
#define OnVehicleSpawn S@@_OnVehicleSpawn
ALS_FORWARD<VehicleSpawn>

public OnVehicleDeath(vehicleid, killerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnVehicleDeath][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnVehicleDeath][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<VehicleDeath>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S killerid
        #emit PUSH.S vehicleid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_VehicleDeath");
        #emit PUSH.S killerid
        #emit PUSH.S vehicleid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<VehicleDeath>
}
#if defined _ALS_OnVehicleDeath
    #undef OnVehicleDeath
#else
    #define _ALS_OnVehicleDeath
#endif
#define OnVehicleDeath S@@_OnVehicleDeath
ALS_FORWARD<VehicleDeath>

public OnPlayerText(playerid, text[])
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerText][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerText][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerText>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S text
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerText");
        #emit PUSH.S text
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerText>
}
#if defined _ALS_OnPlayerText
    #undef OnPlayerText
#else
    #define _ALS_OnPlayerText
#endif
#define OnPlayerText S@@_OnPlayerText
ALS_FORWARD<PlayerText>

public OnPlayerCommandText(playerid, cmdtext[])
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerCommandText][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerCommandText][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerCommandText>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S cmdtext
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerCommandText");
        #emit PUSH.S cmdtext
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerCommandText>
}
#if defined _ALS_OnPlayerCommandText
    #undef OnPlayerCommandText
#else
    #define _ALS_OnPlayerCommandText
#endif
#define OnPlayerCommandText S@@_OnPlayerCommandText
ALS_FORWARD<PlayerCommandText>

public OnPlayerRequestClass(playerid, classid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerRequestClass][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerRequestClass][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerRequestClass>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S classid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerRequestClass");
        #emit PUSH.S classid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerRequestClass>
}
#if defined _ALS_OnPlayerRequestClass
    #undef OnPlayerRequestClass
#else
    #define _ALS_OnPlayerRequestClass
#endif
#define OnPlayerRequestClass S@@_OnPlayerRequestClass
ALS_FORWARD<PlayerRequestClass>

public OnPlayerEnterVehicle(playerid, vehicleid, ispassenger)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerEnterVehicle][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerEnterVehicle][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerEnterVehicle>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S ispassenger
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerEnterVehicle");
        #emit PUSH.S ispassenger
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerEnterVehicle>
}
#if defined _ALS_OnPlayerEnterVehicle
    #undef OnPlayerEnterVehicle
#else
    #define _ALS_OnPlayerEnterVehicle
#endif
#define OnPlayerEnterVehicle S@@_OnPlayerEnterVehicle
ALS_FORWARD<PlayerEnterVehicle>

public OnPlayerExitVehicle(playerid, vehicleid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerExitVehicle][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerExitVehicle][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerExitVehicle>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerExitVehicle");
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerExitVehicle>
}
#if defined _ALS_OnPlayerExitVehicle
    #undef OnPlayerExitVehicle
#else
    #define _ALS_OnPlayerExitVehicle
#endif
#define OnPlayerExitVehicle S@@_OnPlayerExitVehicle
ALS_FORWARD<PlayerExitVehicle>

public OnPlayerStateChange(playerid, newstate, oldstate)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerStateChange][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerStateChange][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerStateChange>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S oldstate
        #emit PUSH.S newstate
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerStateChange");
        #emit PUSH.S oldstate
        #emit PUSH.S newstate
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerStateChange>
}
#if defined _ALS_OnPlayerStateChange
    #undef OnPlayerStateChange
#else
    #define _ALS_OnPlayerStateChange
#endif
#define OnPlayerStateChange S@@_OnPlayerStateChange
ALS_FORWARD<PlayerStateChange>

public OnPlayerEnterCheckpoint(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerEnterCheckpoint][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerEnterCheckpoint][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerEnterCheckpoint>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerEnterCheckpoint");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerEnterCheckpoint>
}
#if defined _ALS_OnPlayerEnterCheckpoint
    #undef OnPlayerEnterCheckpoint
#else
    #define _ALS_OnPlayerEnterCheckpoint
#endif
#define OnPlayerEnterCheckpoint S@@_OnPlayerEnterCheckpoint
ALS_FORWARD<PlayerEnterCheckpoint>

public OnPlayerLeaveCheckpoint(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerLeaveCheckpoint][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerLeaveCheckpoint][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerLeaveCheckpoint>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerLeaveCheckpoint");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerLeaveCheckpoint>
}
#if defined _ALS_OnPlayerLeaveCheckpoint
    #undef OnPlayerLeaveCheckpoint
#else
    #define _ALS_OnPlayerLeaveCheckpoint
#endif
#define OnPlayerLeaveCheckpoint S@@_OnPlayerLeaveCheckpoint
ALS_FORWARD<PlayerLeaveCheckpoint>

public OnPlayerEnterRaceCheckpoint(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerEnterRaceCheckpoint][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerEnterRaceCheckpoint][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerEnterRaceCheckpoint>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerEnterRaceCheckpoint");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerEnterRaceCheckpoint>
}
#if defined _ALS_OnPlayerEnterRaceCP
    #undef OnPlayerEnterRaceCheckpoint
#else
    #define _ALS_OnPlayerEnterRaceCP
#endif
#define OnPlayerEnterRaceCheckpoint S@@_OnPlayerEnterRaceCheckpoint
ALS_FORWARD<PlayerEnterRaceCheckpoint>

public OnPlayerLeaveRaceCheckpoint(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerLeaveRaceCheckpoint][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerLeaveRaceCheckpoint][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerLeaveRaceCheckpoint>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerLeaveRaceCheckpoint");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerLeaveRaceCheckpoint>
}
#if defined _ALS_OnPlayerLeaveRaceCP
    #undef OnPlayerLeaveRaceCheckpoint
#else
    #define _ALS_OnPlayerLeaveRaceCP
#endif
#define OnPlayerLeaveRaceCheckpoint S@@_OnPlayerLeaveRaceCheckpoint
ALS_FORWARD<PlayerLeaveRaceCheckpoint>

public OnRconCommand(cmd[])
{
    new
        end   = YSI_g_sCallbackData[ALS_OnRconCommand][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnRconCommand][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<RconCommand>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S cmd
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_RconCommand");
        #emit PUSH.S cmd
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<RconCommand>
}
#if defined _ALS_OnRconCommand
    #undef OnRconCommand
#else
    #define _ALS_OnRconCommand
#endif
#define OnRconCommand S@@_OnRconCommand
ALS_FORWARD<RconCommand>

public OnPlayerRequestSpawn(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerRequestSpawn][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerRequestSpawn][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerRequestSpawn>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerRequestSpawn");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerRequestSpawn>
}
#if defined _ALS_OnPlayerRequestSpawn
    #undef OnPlayerRequestSpawn
#else
    #define _ALS_OnPlayerRequestSpawn
#endif
#define OnPlayerRequestSpawn S@@_OnPlayerRequestSpawn
ALS_FORWARD<PlayerRequestSpawn>

public OnObjectMoved(objectid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnObjectMoved][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnObjectMoved][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<ObjectMoved>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S objectid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_ObjectMoved");
        #emit PUSH.S objectid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<ObjectMoved>
}
#if defined _ALS_OnObjectMoved
    #undef OnObjectMoved
#else
    #define _ALS_OnObjectMoved
#endif
#define OnObjectMoved S@@_OnObjectMoved
ALS_FORWARD<ObjectMoved>

public OnPlayerObjectMoved(playerid, objectid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerObjectMoved][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerObjectMoved][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerObjectMoved>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S objectid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerObjectMoved");
        #emit PUSH.S objectid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerObjectMoved>
}
#if defined _ALS_OnPlayerObjectMoved
    #undef OnPlayerObjectMoved
#else
    #define _ALS_OnPlayerObjectMoved
#endif
#define OnPlayerObjectMoved S@@_OnPlayerObjectMoved
ALS_FORWARD<PlayerObjectMoved>

public OnPlayerPickUpPickup(playerid, pickupid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerPickUpPickup][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerPickUpPickup][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerPickUpPickup>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S pickupid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerPickUpPickup");
        #emit PUSH.S pickupid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerPickUpPickup>
}
#if defined _ALS_OnPlayerPickUpPickup
    #undef OnPlayerPickUpPickup
#else
    #define _ALS_OnPlayerPickUpPickup
#endif
#define OnPlayerPickUpPickup S@@_OnPlayerPickUpPickup
ALS_FORWARD<PlayerPickUpPickup>

public OnVehicleMod(playerid, vehicleid, componentid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnVehicleMod][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnVehicleMod][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<VehicleMod>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S componentid
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_VehicleMod");
        #emit PUSH.S componentid
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<VehicleMod>
}
#if defined _ALS_OnVehicleMod
    #undef OnVehicleMod
#else
    #define _ALS_OnVehicleMod
#endif
#define OnVehicleMod S@@_OnVehicleMod
ALS_FORWARD<VehicleMod>

public OnEnterExitModShop(playerid, enterexit, interiorid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnEnterExitModShop][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnEnterExitModShop][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<EnterExitModShop>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S interiorid
        #emit PUSH.S enterexit
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_EnterExitModShop");
        #emit PUSH.S interiorid
        #emit PUSH.S enterexit
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<EnterExitModShop>
}
#if defined _ALS_OnEnterExitModShop
    #undef OnEnterExitModShop
#else
    #define _ALS_OnEnterExitModShop
#endif
#define OnEnterExitModShop S@@_OnEnterExitModShop
ALS_FORWARD<EnterExitModShop>

public OnVehiclePaintjob(playerid, vehicleid, paintjobid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnVehiclePaintjob][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnVehiclePaintjob][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<VehiclePaintjob>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S paintjobid
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_VehiclePaintjob");
        #emit PUSH.S paintjobid
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<VehiclePaintjob>
}
#if defined _ALS_OnVehiclePaintjob
    #undef OnVehiclePaintjob
#else
    #define _ALS_OnVehiclePaintjob
#endif
#define OnVehiclePaintjob S@@_OnVehiclePaintjob
ALS_FORWARD<VehiclePaintjob>

public OnVehicleRespray(playerid, vehicleid, color1, color2)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnVehicleRespray][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnVehicleRespray][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<VehicleRespray>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S color2
        #emit PUSH.S color1
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     16
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_VehicleRespray");
        #emit PUSH.S color2
        #emit PUSH.S color1
        #emit PUSH.S vehicleid
        #emit PUSH.S playerid
        #emit PUSH.C     16
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<VehicleRespray>
}
#if defined _ALS_OnVehicleRespray
    #undef OnVehicleRespray
#else
    #define _ALS_OnVehicleRespray
#endif
#define OnVehicleRespray S@@_OnVehicleRespray
ALS_FORWARD<VehicleRespray>

public OnVehicleDamageStatusUpdate(vehicleid, playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnVehicleDamageStatusUpdate][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnVehicleDamageStatusUpdate][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<VehicleDamageStatusUpdate>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.S vehicleid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_VehicleDamageStatusUpdate");
        #emit PUSH.S playerid
        #emit PUSH.S vehicleid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<VehicleDamageStatusUpdate>
}
#if defined _ALS_OnVehicleDamageStatusUpd
    #undef OnVehicleDamageStatusUpdate
#else
    #define _ALS_OnVehicleDamageStatusUpd
#endif
#define OnVehicleDamageStatusUpdate S@@_OnVehicleDamageStatusUpdate
ALS_FORWARD<VehicleDamageStatusUpdate>

public OnPlayerSelectedMenuRow(playerid, row)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerSelectedMenuRow][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerSelectedMenuRow][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerSelectedMenuRow>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S row
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerSelectedMenuRow");
        #emit PUSH.S row
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerSelectedMenuRow>
}
#if defined _ALS_OnPlayerSelectedMenuRow
    #undef OnPlayerSelectedMenuRow
#else
    #define _ALS_OnPlayerSelectedMenuRow
#endif
#define OnPlayerSelectedMenuRow S@@_OnPlayerSelectedMenuRow
ALS_FORWARD<PlayerSelectedMenuRow>

public OnPlayerExitedMenu(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerExitedMenu][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerExitedMenu][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerExitedMenu>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerExitedMenu");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerExitedMenu>
}
#if defined _ALS_OnPlayerExitedMenu
    #undef OnPlayerExitedMenu
#else
    #define _ALS_OnPlayerExitedMenu
#endif
#define OnPlayerExitedMenu S@@_OnPlayerExitedMenu
ALS_FORWARD<PlayerExitedMenu>

public OnPlayerInteriorChange(playerid, newinteriorid, oldinteriorid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerInteriorChange][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerInteriorChange][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerInteriorChange>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S oldinteriorid
        #emit PUSH.S newinteriorid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerInteriorChange");
        #emit PUSH.S oldinteriorid
        #emit PUSH.S newinteriorid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerInteriorChange>
}
#if defined _ALS_OnPlayerInteriorChange
    #undef OnPlayerInteriorChange
#else
    #define _ALS_OnPlayerInteriorChange
#endif
#define OnPlayerInteriorChange S@@_OnPlayerInteriorChange
ALS_FORWARD<PlayerInteriorChange>

public OnPlayerKeyStateChange(playerid, newkeys, oldkeys)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerKeyStateChange][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerKeyStateChange][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerKeyStateChange>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S oldkeys
        #emit PUSH.S newkeys
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerKeyStateChange");
        #emit PUSH.S oldkeys
        #emit PUSH.S newkeys
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerKeyStateChange>
}
#if defined _ALS_OnPlayerKeyStateChange
    #undef OnPlayerKeyStateChange
#else
    #define _ALS_OnPlayerKeyStateChange
#endif
#define OnPlayerKeyStateChange S@@_OnPlayerKeyStateChange
ALS_FORWARD<PlayerKeyStateChange>

public OnRconLoginAttempt(ip[], password[], success)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnRconLoginAttempt][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnRconLoginAttempt][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<RconLoginAttempt>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S success
        #emit PUSH.S password
        #emit PUSH.S ip
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_RconLoginAttempt");
        #emit PUSH.S success
        #emit PUSH.S password
        #emit PUSH.S ip
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<RconLoginAttempt>
}
#if defined _ALS_OnRconLoginAttempt
    #undef OnRconLoginAttempt
#else
    #define _ALS_OnRconLoginAttempt
#endif
#define OnRconLoginAttempt S@@_OnRconLoginAttempt
ALS_FORWARD<RconLoginAttempt>

public OnPlayerUpdate(playerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerUpdate][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerUpdate][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerUpdate>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerUpdate");
        #emit PUSH.S playerid
        #emit PUSH.C     4
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerUpdate>
}
#if defined _ALS_OnPlayerUpdate
    #undef OnPlayerUpdate
#else
    #define _ALS_OnPlayerUpdate
#endif
#define OnPlayerUpdate S@@_OnPlayerUpdate
ALS_FORWARD<PlayerUpdate>

public OnPlayerStreamIn(playerid, forplayerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerStreamIn][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerStreamIn][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerStreamIn>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S forplayerid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerStreamIn");
        #emit PUSH.S forplayerid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerStreamIn>
}
#if defined _ALS_OnPlayerStreamIn
    #undef OnPlayerStreamIn
#else
    #define _ALS_OnPlayerStreamIn
#endif
#define OnPlayerStreamIn S@@_OnPlayerStreamIn
ALS_FORWARD<PlayerStreamIn>

public OnPlayerStreamOut(playerid, forplayerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerStreamOut][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerStreamOut][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerStreamOut>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S forplayerid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerStreamOut");
        #emit PUSH.S forplayerid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerStreamOut>
}
#if defined _ALS_OnPlayerStreamOut
    #undef OnPlayerStreamOut
#else
    #define _ALS_OnPlayerStreamOut
#endif
#define OnPlayerStreamOut S@@_OnPlayerStreamOut
ALS_FORWARD<PlayerStreamOut>

public OnVehicleStreamIn(vehicleid, forplayerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnVehicleStreamIn][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnVehicleStreamIn][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<VehicleStreamIn>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S forplayerid
        #emit PUSH.S vehicleid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_VehicleStreamIn");
        #emit PUSH.S forplayerid
        #emit PUSH.S vehicleid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<VehicleStreamIn>
}
#if defined _ALS_OnVehicleStreamIn
    #undef OnVehicleStreamIn
#else
    #define _ALS_OnVehicleStreamIn
#endif
#define OnVehicleStreamIn S@@_OnVehicleStreamIn
ALS_FORWARD<VehicleStreamIn>

public OnVehicleStreamOut(vehicleid, forplayerid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnVehicleStreamOut][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnVehicleStreamOut][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<VehicleStreamOut>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S forplayerid
        #emit PUSH.S vehicleid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_VehicleStreamOut");
        #emit PUSH.S forplayerid
        #emit PUSH.S vehicleid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<VehicleStreamOut>
}
#if defined _ALS_OnVehicleStreamOut
    #undef OnVehicleStreamOut
#else
    #define _ALS_OnVehicleStreamOut
#endif
#define OnVehicleStreamOut S@@_OnVehicleStreamOut
ALS_FORWARD<VehicleStreamOut>

public OnDialogResponse(playerid, dialogid, response, listitem, inputtext[])
{
    new
        end   = YSI_g_sCallbackData[ALS_OnDialogResponse][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnDialogResponse][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<DialogResponse>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S inputtext
        #emit PUSH.S listitem
        #emit PUSH.S response
        #emit PUSH.S dialogid
        #emit PUSH.S playerid
        #emit PUSH.C     20
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_DialogResponse");
        #emit PUSH.S inputtext
        #emit PUSH.S listitem
        #emit PUSH.S response
        #emit PUSH.S dialogid
        #emit PUSH.S playerid
        #emit PUSH.C     20
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<DialogResponse>
}
#if defined _ALS_OnDialogResponse
    #undef OnDialogResponse
#else
    #define _ALS_OnDialogResponse
#endif
#define OnDialogResponse S@@_OnDialogResponse
ALS_FORWARD<DialogResponse>

public OnPlayerClickPlayer(playerid, clickedplayerid, source)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerClickPlayer][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerClickPlayer][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerClickPlayer>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S source
        #emit PUSH.S clickedplayerid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerClickPlayer");
        #emit PUSH.S source
        #emit PUSH.S clickedplayerid
        #emit PUSH.S playerid
        #emit PUSH.C     12
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerClickPlayer>
}
#if defined _ALS_OnPlayerClickPlayer
    #undef OnPlayerClickPlayer
#else
    #define _ALS_OnPlayerClickPlayer
#endif
#define OnPlayerClickPlayer S@@_OnPlayerClickPlayer
ALS_FORWARD<PlayerClickPlayer>

/*public OnPlayerLogin(playerid, uid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerLogin][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerLogin][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerLogin>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S uid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerLogin");
        #emit PUSH.S uid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerLogin>
}
#if defined _ALS_OnPlayerLogin
    #undef OnPlayerLogin
#else
    #define _ALS_OnPlayerLogin
#endif
#define OnPlayerLogin S@@_OnPlayerLogin
ALS_FORWARD<PlayerLogin>

public OnPlayerLogout(playerid, uid)
{
    new
        end   = YSI_g_sCallbackData[ALS_OnPlayerLogout][E_FUNC_HOOK_DATA_END],
        start = YSI_g_sCallbackData[ALS_OnPlayerLogout][E_FUNC_HOOK_DATA_START],
        pointer,
        idx,
        re = end;
    if (start == end) ALS_CALL<PlayerLogout>
    if (end > sizeof (YSI_g_sCallbackAddresses))
    {
        re = sizeof (YSI_g_sCallbackAddresses);
        if (start != sizeof (YSI_g_sCallbackAddresses)) idx = YSI_g_sLastFoundIndex;
    }
    // Do the initial fast elements.
    while (start != re)
    {
        pointer = YSI_g_sCallbackAddresses[start++];
        #emit PUSH.S uid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Get any remaining pointers the old way.
    while (start++ != end)
    {
        idx = AMX_GetPublicPointer(idx, pointer, "@yH_PlayerLogout");
        #emit PUSH.S uid
        #emit PUSH.S playerid
        #emit PUSH.C     8
        #emit LCTRL      6
        #emit ADD.C      28
        #emit PUSH.pri
        #emit LOAD.S.pri pointer
        #emit SCTRL      6
    }
    // Do ALS just in case (YSI no longer uses this though now).
    ALS_CALL<PlayerLogout>
}
#if defined _ALS_OnPlayerLogout
    #undef OnPlayerLogout
#else
    #define _ALS_OnPlayerLogout
#endif
#define OnPlayerLogout S@@_OnPlayerlogout
ALS_FORWARD<PlayerLogout>*/