text: //----------------------------------------------------------
  //
  //   SA:MP Multiplayer Modification For GTA:SA
  //   Copyright 2004-2007 SA:MP Team
  //
  //----------------------------------------------------------
  
  //
  // This provides an interface to call amx library functions
  // within samp-server.
  //
  // To use:
  //    Define the extern in your main source file:
  //        extern void *pAMXFunctions;
  //    And, in your Initialize function, assign:
  //        pAMXFunctions = data[PLUGIN_DATA_AMX];
  //
  //
  // WIN32: To regenerate thunks for calls from prototypes in amx.h
  // Run a regex with:
  //   S: ^(.*)(AMXAPI amx_)([^(]*)([^\;]*);$
  //   R: NUDE \1\2\3\4\n{\n\t_asm mov eax, pAMXFunctions;\n\t_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_\3*4];\n}\n
  //
  // LINUX/BSD: To regenerate thunks for calls from prototypes in amx.h
  // Run a regex with:
  //   S: ^(.*)(AMXAPI amx_)([^(]*)([^\;]*);$
  //   R: typedef \1 AMXAPI (*amx_\3_t)\4;\n\1\2\3\4\n{\n\tamx_\3_t fn = ((amx_\3_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_\3];\n\treturn fn\4;\n}\n
  // Modify internal function calls as nessesary
  //
  
  //----------------------------------------------------------
  
  #include "plugin.h"
  
  //----------------------------------------------------------
  
  void *pAMXFunctions;
  
  //----------------------------------------------------------
  
  #if (defined(WIN32) || defined(_WIN32)) && defined(_MSC_VER)
  
  // Optimized Inline Assembly Thunks for MS VC++
  
  #define NUDE _declspec(naked) 
  
  NUDE uint16_t * AMXAPI amx_Align16(uint16_t *v)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Align16*4];
  }
  
  NUDE uint32_t * AMXAPI amx_Align32(uint32_t *v)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Align32*4];
  }
  
  #if defined _I64_MAX || defined HAVE_I64
  NUDE   uint64_t * AMXAPI amx_Align64(uint64_t *v)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Align64*4];
  }
  
  #endif
  NUDE int AMXAPI amx_Allot(AMX *amx, int cells, cell *amx_addr, cell **phys_addr)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Allot*4];
  }
  
  NUDE int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Callback*4];
  }
  
  NUDE int AMXAPI amx_Cleanup(AMX *amx)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Cleanup*4];
  }
  
  NUDE int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Clone*4];
  }
  
  NUDE int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Exec*4];
  }
  
  NUDE int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_FindNative*4];
  }
  
  NUDE int AMXAPI amx_FindPublic(AMX *amx, const char *funcname, int *index)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_FindPublic*4];
  }
  
  NUDE int AMXAPI amx_FindPubVar(AMX *amx, const char *varname, cell *amx_addr)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_FindPubVar*4];
  }
  
  NUDE int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_FindTagId*4];
  }
  
  NUDE int AMXAPI amx_Flags(AMX *amx,uint16_t *flags)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Flags*4];
  }
  
  NUDE int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_GetAddr*4];
  }
  
  NUDE int AMXAPI amx_GetNative(AMX *amx, int index, char *funcname)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_GetNative*4];
  }
  
  NUDE int AMXAPI amx_GetPublic(AMX *amx, int index, char *funcname)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_GetPublic*4];
  }
  
  NUDE int AMXAPI amx_GetPubVar(AMX *amx, int index, char *varname, cell *amx_addr)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_GetPubVar*4];
  }
  
  NUDE int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar, size_t size)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_GetString*4];
  }
  
  NUDE int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_GetTag*4];
  }
  
  NUDE int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_GetUserData*4];
  }
  
  NUDE int AMXAPI amx_Init(AMX *amx, void *program)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Init*4];
  }
  
  NUDE int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_InitJIT*4];
  }
  
  NUDE int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_MemInfo*4];
  }
  
  NUDE int AMXAPI amx_NameLength(AMX *amx, int *length)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_NameLength*4];
  }
  
  NUDE AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name, AMX_NATIVE func)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_NativeInfo*4];
  }
  
  NUDE int AMXAPI amx_NumNatives(AMX *amx, int *number)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_NumNatives*4];
  }
  
  NUDE int AMXAPI amx_NumPublics(AMX *amx, int *number)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_NumPublics*4];
  }
  
  NUDE int AMXAPI amx_NumPubVars(AMX *amx, int *number)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_NumPubVars*4];
  }
  
  NUDE int AMXAPI amx_NumTags(AMX *amx, int *number)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_NumTags*4];
  }
  
  NUDE int AMXAPI amx_Push(AMX *amx, cell value)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Push*4];
  }
  
  NUDE int AMXAPI amx_PushArray(AMX *amx, cell *amx_addr, cell **phys_addr, const cell array[], int numcells)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_PushArray*4];
  }
  
  NUDE int AMXAPI amx_PushString(AMX *amx, cell *amx_addr, cell **phys_addr, const char *string, int pack, int use_wchar)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_PushString*4];
  }
  
  NUDE int AMXAPI amx_RaiseError(AMX *amx, int error)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_RaiseError*4];
  }
  
  NUDE int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Register*4];
  }
  
  NUDE int AMXAPI amx_Release(AMX *amx, cell amx_addr)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_Release*4];
  }
  
  NUDE int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_SetCallback*4];
  }
  
  NUDE int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_SetDebugHook*4];
  }
  
  NUDE int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar, size_t size)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_SetString*4];
  }
  
  NUDE int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_SetUserData*4];
  }
  
  NUDE int AMXAPI amx_StrLen(const cell *cstring, int *length)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_StrLen*4];
  }
  
  NUDE int AMXAPI amx_UTF8Check(const char *string, int *length)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_UTF8Check*4];
  }
  
  NUDE int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_UTF8Get*4];
  }
  
  NUDE int AMXAPI amx_UTF8Len(const cell *cstr, int *length)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_UTF8Len*4];
  }
  
  NUDE int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value)
  {
  	_asm mov eax, pAMXFunctions;
  	_asm jmp dword ptr [eax+PLUGIN_AMX_EXPORT_UTF8Put*4];
  }
  
  #else
  
  // Unoptimized Thunks (Linux/BSD/non MSVC++)
  
  typedef uint16_t *  AMXAPI (*amx_Align16_t)(uint16_t *v);
  uint16_t * AMXAPI amx_Align16(uint16_t *v)
  {
  	amx_Align16_t fn = ((amx_Align16_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Align16];
  	return fn(v);
  }
  
  typedef uint32_t *  AMXAPI (*amx_Align32_t)(uint32_t *v);
  uint32_t * AMXAPI amx_Align32(uint32_t *v)
  {
  	amx_Align32_t fn = ((amx_Align32_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Align32];
  	return fn(v);
  }
  
  #if defined _I64_MAX || defined HAVE_I64
  typedef   uint64_t *  AMXAPI (*amx_Align64_t)(uint64_t *v);
    uint64_t * AMXAPI amx_Align64(uint64_t *v)
  {
  	amx_Align64_t fn = ((amx_Align64_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Align64];
  	return fn(v);
  }
  
  #endif
  typedef int  AMXAPI (*amx_Allot_t)(AMX *amx, int cells, cell *amx_addr, cell **phys_addr);
  int AMXAPI amx_Allot(AMX *amx, int cells, cell *amx_addr, cell **phys_addr)
  {
  	amx_Allot_t fn = ((amx_Allot_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Allot];
  	return fn(amx, cells, amx_addr, phys_addr);
  }
  
  typedef int  AMXAPI (*amx_Callback_t)(AMX *amx, cell index, cell *result, cell *params);
  int AMXAPI amx_Callback(AMX *amx, cell index, cell *result, cell *params)
  {
  	amx_Callback_t fn = ((amx_Callback_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Callback];
  	return fn(amx, index, result, params);
  }
  
  typedef int  AMXAPI (*amx_Cleanup_t)(AMX *amx);
  int AMXAPI amx_Cleanup(AMX *amx)
  {
  	amx_Cleanup_t fn = ((amx_Cleanup_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Cleanup];
  	return fn(amx);
  }
  
  typedef int  AMXAPI (*amx_Clone_t)(AMX *amxClone, AMX *amxSource, void *data);
  int AMXAPI amx_Clone(AMX *amxClone, AMX *amxSource, void *data)
  {
  	amx_Clone_t fn = ((amx_Clone_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Clone];
  	return fn(amxClone, amxSource, data);
  }
  
  typedef int  AMXAPI (*amx_Exec_t)(AMX *amx, cell *retval, int index);
  int AMXAPI amx_Exec(AMX *amx, cell *retval, int index)
  {
  	amx_Exec_t fn = ((amx_Exec_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Exec];
  	return fn(amx, retval, index);
  }
  
  typedef int  AMXAPI (*amx_FindNative_t)(AMX *amx, const char *name, int *index);
  int AMXAPI amx_FindNative(AMX *amx, const char *name, int *index)
  {
  	amx_FindNative_t fn = ((amx_FindNative_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_FindNative];
  	return fn(amx, name, index);
  }
  
  typedef int  AMXAPI (*amx_FindPublic_t)(AMX *amx, const char *funcname, int *index);
  int AMXAPI amx_FindPublic(AMX *amx, const char *funcname, int *index)
  {
  	amx_FindPublic_t fn = ((amx_FindPublic_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_FindPublic];
  	return fn(amx, funcname, index);
  }
  
  typedef int  AMXAPI (*amx_FindPubVar_t)(AMX *amx, const char *varname, cell *amx_addr);
  int AMXAPI amx_FindPubVar(AMX *amx, const char *varname, cell *amx_addr)
  {
  	amx_FindPubVar_t fn = ((amx_FindPubVar_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_FindPubVar];
  	return fn(amx, varname, amx_addr);
  }
  
  typedef int  AMXAPI (*amx_FindTagId_t)(AMX *amx, cell tag_id, char *tagname);
  int AMXAPI amx_FindTagId(AMX *amx, cell tag_id, char *tagname)
  {
  	amx_FindTagId_t fn = ((amx_FindTagId_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_FindTagId];
  	return fn(amx, tag_id, tagname);
  }
  
  typedef int  AMXAPI (*amx_Flags_t)(AMX *amx,uint16_t *flags);
  int AMXAPI amx_Flags(AMX *amx,uint16_t *flags)
  {
  	amx_Flags_t fn = ((amx_Flags_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Flags];
  	return fn(amx,flags);
  }
  
  typedef int  AMXAPI (*amx_GetAddr_t)(AMX *amx,cell amx_addr,cell **phys_addr);
  int AMXAPI amx_GetAddr(AMX *amx,cell amx_addr,cell **phys_addr)
  {
  	amx_GetAddr_t fn = ((amx_GetAddr_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_GetAddr];
  	return fn(amx,amx_addr,phys_addr);
  }
  
  typedef int  AMXAPI (*amx_GetNative_t)(AMX *amx, int index, char *funcname);
  int AMXAPI amx_GetNative(AMX *amx, int index, char *funcname)
  {
  	amx_GetNative_t fn = ((amx_GetNative_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_GetNative];
  	return fn(amx, index, funcname);
  }
  
  typedef int  AMXAPI (*amx_GetPublic_t)(AMX *amx, int index, char *funcname);
  int AMXAPI amx_GetPublic(AMX *amx, int index, char *funcname)
  {
  	amx_GetPublic_t fn = ((amx_GetPublic_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_GetPublic];
  	return fn(amx, index, funcname);
  }
  
  typedef int  AMXAPI (*amx_GetPubVar_t)(AMX *amx, int index, char *varname, cell *amx_addr);
  int AMXAPI amx_GetPubVar(AMX *amx, int index, char *varname, cell *amx_addr)
  {
  	amx_GetPubVar_t fn = ((amx_GetPubVar_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_GetPubVar];
  	return fn(amx, index, varname, amx_addr);
  }
  
  typedef int  AMXAPI (*amx_GetString_t)(char *dest,const cell *source, int use_wchar, size_t size);
  int AMXAPI amx_GetString(char *dest,const cell *source, int use_wchar, size_t size)
  {
  	amx_GetString_t fn = ((amx_GetString_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_GetString];
  	return fn(dest,source, use_wchar, size);
  }
  
  typedef int  AMXAPI (*amx_GetTag_t)(AMX *amx, int index, char *tagname, cell *tag_id);
  int AMXAPI amx_GetTag(AMX *amx, int index, char *tagname, cell *tag_id)
  {
  	amx_GetTag_t fn = ((amx_GetTag_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_GetTag];
  	return fn(amx, index, tagname, tag_id);
  }
  
  typedef int  AMXAPI (*amx_GetUserData_t)(AMX *amx, long tag, void **ptr);
  int AMXAPI amx_GetUserData(AMX *amx, long tag, void **ptr)
  {
  	amx_GetUserData_t fn = ((amx_GetUserData_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_GetUserData];
  	return fn(amx, tag, ptr);
  }
  
  typedef int  AMXAPI (*amx_Init_t)(AMX *amx, void *program);
  int AMXAPI amx_Init(AMX *amx, void *program)
  {
  	amx_Init_t fn = ((amx_Init_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Init];
  	return fn(amx, program);
  }
  
  typedef int  AMXAPI (*amx_InitJIT_t)(AMX *amx, void *reloc_table, void *native_code);
  int AMXAPI amx_InitJIT(AMX *amx, void *reloc_table, void *native_code)
  {
  	amx_InitJIT_t fn = ((amx_InitJIT_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_InitJIT];
  	return fn(amx, reloc_table, native_code);
  }
  
  typedef int  AMXAPI (*amx_MemInfo_t)(AMX *amx, long *codesize, long *datasize, long *stackheap);
  int AMXAPI amx_MemInfo(AMX *amx, long *codesize, long *datasize, long *stackheap)
  {
  	amx_MemInfo_t fn = ((amx_MemInfo_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_MemInfo];
  	return fn(amx, codesize, datasize, stackheap);
  }
  
  typedef int  AMXAPI (*amx_NameLength_t)(AMX *amx, int *length);
  int AMXAPI amx_NameLength(AMX *amx, int *length)
  {
  	amx_NameLength_t fn = ((amx_NameLength_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_NameLength];
  	return fn(amx, length);
  }
  
  typedef AMX_NATIVE_INFO *  AMXAPI (*amx_NativeInfo_t)(const char *name, AMX_NATIVE func);
  AMX_NATIVE_INFO * AMXAPI amx_NativeInfo(const char *name, AMX_NATIVE func)
  {
  	amx_NativeInfo_t fn = ((amx_NativeInfo_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_NativeInfo];
  	return fn(name, func);
  }
  
  typedef int  AMXAPI (*amx_NumNatives_t)(AMX *amx, int *number);
  int AMXAPI amx_NumNatives(AMX *amx, int *number)
  {
  	amx_NumNatives_t fn = ((amx_NumNatives_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_NumNatives];
  	return fn(amx, number);
  }
  
  typedef int  AMXAPI (*amx_NumPublics_t)(AMX *amx, int *number);
  int AMXAPI amx_NumPublics(AMX *amx, int *number)
  {
  	amx_NumPublics_t fn = ((amx_NumPublics_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_NumPublics];
  	return fn(amx, number);
  }
  
  typedef int  AMXAPI (*amx_NumPubVars_t)(AMX *amx, int *number);
  int AMXAPI amx_NumPubVars(AMX *amx, int *number)
  {
  	amx_NumPubVars_t fn = ((amx_NumPubVars_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_NumPubVars];
  	return fn(amx, number);
  }
  
  typedef int  AMXAPI (*amx_NumTags_t)(AMX *amx, int *number);
  int AMXAPI amx_NumTags(AMX *amx, int *number)
  {
  	amx_NumTags_t fn = ((amx_NumTags_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_NumTags];
  	return fn(amx, number);
  }
  
  typedef int  AMXAPI (*amx_Push_t)(AMX *amx, cell value);
  int AMXAPI amx_Push(AMX *amx, cell value)
  {
  	amx_Push_t fn = ((amx_Push_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Push];
  	return fn(amx, value);
  }
  
  typedef int  AMXAPI (*amx_PushArray_t)(AMX *amx, cell *amx_addr, cell **phys_addr, const cell array[], int numcells);
  int AMXAPI amx_PushArray(AMX *amx, cell *amx_addr, cell **phys_addr, const cell array[], int numcells)
  {
  	amx_PushArray_t fn = ((amx_PushArray_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_PushArray];
  	return fn(amx, amx_addr, phys_addr, array, numcells);
  }
  
  typedef int  AMXAPI (*amx_PushString_t)(AMX *amx, cell *amx_addr, cell **phys_addr, const char *string, int pack, int use_wchar);
  int AMXAPI amx_PushString(AMX *amx, cell *amx_addr, cell **phys_addr, const char *string, int pack, int use_wchar)
  {
  	amx_PushString_t fn = ((amx_PushString_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_PushString];
  	return fn(amx, amx_addr, phys_addr, string, pack, use_wchar);
  }
  
  typedef int  AMXAPI (*amx_RaiseError_t)(AMX *amx, int error);
  int AMXAPI amx_RaiseError(AMX *amx, int error)
  {
  	amx_RaiseError_t fn = ((amx_RaiseError_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_RaiseError];
  	return fn(amx, error);
  }
  
  typedef int  AMXAPI (*amx_Register_t)(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number);
  int AMXAPI amx_Register(AMX *amx, const AMX_NATIVE_INFO *nativelist, int number)
  {
  	amx_Register_t fn = ((amx_Register_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Register];
  	return fn(amx, nativelist, number);
  }
  
  typedef int  AMXAPI (*amx_Release_t)(AMX *amx, cell amx_addr);
  int AMXAPI amx_Release(AMX *amx, cell amx_addr)
  {
  	amx_Release_t fn = ((amx_Release_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_Release];
  	return fn(amx, amx_addr);
  }
  
  typedef int  AMXAPI (*amx_SetCallback_t)(AMX *amx, AMX_CALLBACK callback);
  int AMXAPI amx_SetCallback(AMX *amx, AMX_CALLBACK callback)
  {
  	amx_SetCallback_t fn = ((amx_SetCallback_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_SetCallback];
  	return fn(amx, callback);
  }
  
  typedef int  AMXAPI (*amx_SetDebugHook_t)(AMX *amx, AMX_DEBUG debug);
  int AMXAPI amx_SetDebugHook(AMX *amx, AMX_DEBUG debug)
  {
  	amx_SetDebugHook_t fn = ((amx_SetDebugHook_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_SetDebugHook];
  	return fn(amx, debug);
  }
  
  typedef int  AMXAPI (*amx_SetString_t)(cell *dest, const char *source, int pack, int use_wchar, size_t size);
  int AMXAPI amx_SetString(cell *dest, const char *source, int pack, int use_wchar, size_t size)
  {
  	amx_SetString_t fn = ((amx_SetString_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_SetString];
  	return fn(dest, source, pack, use_wchar, size);
  }
  
  typedef int  AMXAPI (*amx_SetUserData_t)(AMX *amx, long tag, void *ptr);
  int AMXAPI amx_SetUserData(AMX *amx, long tag, void *ptr)
  {
  	amx_SetUserData_t fn = ((amx_SetUserData_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_SetUserData];
  	return fn(amx, tag, ptr);
  }
  
  typedef int  AMXAPI (*amx_StrLen_t)(const cell *cstring, int *length);
  int AMXAPI amx_StrLen(const cell *cstring, int *length)
  {
  	amx_StrLen_t fn = ((amx_StrLen_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_StrLen];
  	return fn(cstring, length);
  }
  
  typedef int  AMXAPI (*amx_UTF8Check_t)(const char *string, int *length);
  int AMXAPI amx_UTF8Check(const char *string, int *length)
  {
  	amx_UTF8Check_t fn = ((amx_UTF8Check_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_UTF8Check];
  	return fn(string, length);
  }
  
  typedef int  AMXAPI (*amx_UTF8Get_t)(const char *string, const char **endptr, cell *value);
  int AMXAPI amx_UTF8Get(const char *string, const char **endptr, cell *value)
  {
  	amx_UTF8Get_t fn = ((amx_UTF8Get_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_UTF8Get];
  	return fn(string, endptr, value);
  }
  
  typedef int  AMXAPI (*amx_UTF8Len_t)(const cell *cstr, int *length);
  int AMXAPI amx_UTF8Len(const cell *cstr, int *length)
  {
  	amx_UTF8Len_t fn = ((amx_UTF8Len_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_UTF8Len];
  	return fn(cstr, length);
  }
  
  typedef int  AMXAPI (*amx_UTF8Put_t)(char *string, char **endptr, int maxchars, cell value);
  int AMXAPI amx_UTF8Put(char *string, char **endptr, int maxchars, cell value)
  {
  	amx_UTF8Put_t fn = ((amx_UTF8Put_t*)pAMXFunctions)[PLUGIN_AMX_EXPORT_UTF8Put];
  	return fn(string, endptr, maxchars, value);
  }
  
  #endif
  
  //----------------------------------------------------------
  // EOF
  