19 files changed, 76225 insertions, 102 deletions

diff --git a/src/common/HPM.c b/src/common/HPM.c
index 9895ae95d..8be9298f9 100644
--- a/src/common/HPM.c
+++ b/src/common/HPM.c
@@ -40,7 +40,7 @@ void hplugin_export_symbol(void *var, char *name) {
 	HPM->symbols[HPM->symbol_count - 1]->ptr = var;
 }
 
-void *hplugin_import_symbol(char *name) {
+void *hplugin_import_symbol(char *name, unsigned int pID) {
 	unsigned int i;
 	
 	for( i = 0; i < HPM->symbol_count; i++ ) {
@@ -48,7 +48,7 @@ void *hplugin_import_symbol(char *name) {
 			return HPM->symbols[i]->ptr;
 	}
 	
-	ShowError("HPM:get_symbol: '"CL_WHITE"%s"CL_RESET"' not found!\n",name);
+	ShowError("HPM:get_symbol:%s: '"CL_WHITE"%s"CL_RESET"' not found!\n",HPM->pid2name(pID),name);
 	return NULL;
 }
 
@@ -59,7 +59,7 @@ bool hplugin_iscompatible(char* version) {
 		return false;
 	
 	sscanf(version, "%u.%u", &req_major, &req_minor);
-	
+
 	return ( req_major == HPM->version[0] && req_minor <= HPM->version[1] ) ? true : false;
 }
 
@@ -108,7 +108,7 @@ bool hplugin_populate(struct hplugin *plugin, const char *filename) {
 	
 	return true;
 }
-void hplugin_load(const char* filename) {
+struct hplugin *hplugin_load(const char* filename) {
 	struct hplugin *plugin;
 	struct hplugin_info *info;
 	struct HPMi_interface **HPMi;
@@ -118,7 +118,7 @@ void hplugin_load(const char* filename) {
 		
 	if( HPM->exists(filename) ) {
 		ShowWarning("HPM:plugin_load: attempting to load duplicate '"CL_WHITE"%s"CL_RESET"', skipping...\n", filename);
-		return;
+		return NULL;
 	}
 	
 	plugin = HPM->create();
@@ -126,30 +126,33 @@ void hplugin_load(const char* filename) {
 	if( !( plugin->dll = plugin_open(filename) ) ){
 		ShowWarning("HPM:plugin_load: failed to load '"CL_WHITE"%s"CL_RESET"', skipping...\n", filename);
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
 	
 	if( !( info = plugin_import(plugin->dll, "pinfo",struct hplugin_info*) ) ) {
 		ShowDebug("HPM:plugin_load: failed to retrieve 'plugin_info' for '"CL_WHITE"%s"CL_RESET"', skipping...\n", filename);
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
 	
 	if( !(info->type & SERVER_TYPE) ) {
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
 	
 	if( !HPM->iscompatible(info->req_version) ) {
 		ShowWarning("HPM:plugin_load: '"CL_WHITE"%s"CL_RESET"' incompatible version '%s' -> '%s', skipping...\n", filename, info->req_version, HPM_VERSION);
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
-		
+	
+	plugin->info = info;
+	plugin->filename = aStrdup(filename);
+	
 	if( !( import_symbol_ref = plugin_import(plugin->dll, "import_symbol",void **) ) ) {
 		ShowWarning("HPM:plugin_load: failed to retrieve 'import_symbol' for '"CL_WHITE"%s"CL_RESET"', skipping...\n", filename);
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
 	
 	*import_symbol_ref = HPM->import_symbol;
@@ -157,21 +160,21 @@ void hplugin_load(const char* filename) {
 	if( !( sql_handle = plugin_import(plugin->dll, "mysql_handle",Sql **) ) ) {
 		ShowWarning("HPM:plugin_load: failed to retrieve 'mysql_handle' for '"CL_WHITE"%s"CL_RESET"', skipping...\n", filename);
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
 	
-	*sql_handle = HPM->import_symbol("sql_handle");
+	*sql_handle = HPM->import_symbol("sql_handle",plugin->idx);
 
 	if( !( HPMi = plugin_import(plugin->dll, "HPMi",struct HPMi_interface **) ) ) {
 		ShowWarning("HPM:plugin_load: failed to retrieve 'HPMi' for '"CL_WHITE"%s"CL_RESET"', skipping...\n", filename);
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
 	
 	if( !( *HPMi = plugin_import(plugin->dll, "HPMi_s",struct HPMi_interface *) ) ) {
 		ShowWarning("HPM:plugin_load: failed to retrieve 'HPMi_s' for '"CL_WHITE"%s"CL_RESET"', skipping...\n", filename);
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
 	plugin->hpi = *HPMi;
 		
@@ -184,30 +187,34 @@ void hplugin_load(const char* filename) {
 	if( ( plugin->hpi->event[HPET_READY] = plugin_import(plugin->dll, "server_online",void (*)(void)) ) )
 		anyEvent = true;
 	
+	if( ( plugin->hpi->event[HPET_POST_FINAL] = plugin_import(plugin->dll, "server_post_final",void (*)(void)) ) )
+		anyEvent = true;
+	
 	if( !anyEvent ) {
 		ShowWarning("HPM:plugin_load: no events found for '"CL_WHITE"%s"CL_RESET"', skipping...\n", filename);
 		HPM->unload(plugin);
-		return;
+		return NULL;
 	}
 	
 	if( !HPM->populate(plugin,filename) )
-		return;
+		return NULL;
+	
 	/* id */
 	plugin->hpi->pid				= plugin->idx;
 	/* core */
-	plugin->hpi->addCPCommand		= HPM->import_symbol("addCPCommand");
-	plugin->hpi->addPacket			= HPM->import_symbol("addPacket");
-	plugin->hpi->addToSession		= HPM->import_symbol("addToSession");
-	plugin->hpi->getFromSession		= HPM->import_symbol("getFromSession");
-	plugin->hpi->removeFromSession	= HPM->import_symbol("removeFromSession");
+	plugin->hpi->addCPCommand		= HPM->import_symbol("addCPCommand",plugin->idx);
+	plugin->hpi->addPacket			= HPM->import_symbol("addPacket",plugin->idx);
+	plugin->hpi->addToSession		= HPM->import_symbol("addToSession",plugin->idx);
+	plugin->hpi->getFromSession		= HPM->import_symbol("getFromSession",plugin->idx);
+	plugin->hpi->removeFromSession	= HPM->import_symbol("removeFromSession",plugin->idx);
+	plugin->hpi->AddHook			= HPM->import_symbol("AddHook",plugin->idx);
+	plugin->hpi->HookStop			= HPM->import_symbol("HookStop",plugin->idx);
+	plugin->hpi->HookStopped		= HPM->import_symbol("HookStopped",plugin->idx);
 	/* server specific */
 	if( HPM->load_sub )
 		HPM->load_sub(plugin);
-	
-	plugin->info = info;
-	plugin->filename = aStrdup(filename);
-			
-	return;
+				
+	return plugin;
 }
 
 void hplugin_unload(struct hplugin* plugin) {
@@ -253,8 +260,26 @@ void hplugins_config_read(void) {
 		int length = config_setting_length(plist), i;
 		char filename[60];
 		for(i = 0; i < length; i++) {
-			snprintf(filename, 60, "plugins/%s%s", config_setting_get_string_elem(plist,i), DLL_EXT);
-			HPM->load(filename);
+			if( !strcmpi(config_setting_get_string_elem(plist,i),"HPMHooking") ) {//must load it first
+				struct hplugin *plugin;
+				snprintf(filename, 60, "plugins/%s%s", config_setting_get_string_elem(plist,i), DLL_EXT);
+				if( ( plugin = HPM->load(filename) )  ) {
+					bool (*func)(bool *fr);
+					bool (*addhook_sub) (enum HPluginHookType type, const char *target, void *hook, unsigned int pID);
+					if( ( func = plugin_import(plugin->dll, "Hooked",bool (*)(bool *)) ) && ( addhook_sub = plugin_import(plugin->dll, "HPM_Plugin_AddHook",bool (*)(enum HPluginHookType, const char *, void *, unsigned int)) ) ) {
+						if( func(&HPM->force_return) ) {
+							HPM->hooking = true;
+							HPM->addhook_sub = addhook_sub;
+						}
+					}
+				}
+			}
+		}
+		for(i = 0; i < length; i++) {
+			if( strcmpi(config_setting_get_string_elem(plist,i),"HPMHooking") ) {//now all others
+				snprintf(filename, 60, "plugins/%s%s", config_setting_get_string_elem(plist,i), DLL_EXT);
+				HPM->load(filename);
+			}
 		}
 		config_destroy(&plugins_conf);
 	}
@@ -436,6 +461,25 @@ void* HPM_realloc(void *p, size_t size, const char *file, int line, const char *
 char* HPM_astrdup(const char *p, const char *file, int line, const char *func) {
 	return iMalloc->astrdup(p,HPM_file2ptr(file),line,func);
 }
+/* todo: add ability for tracking using pID for the upcoming runtime load/unload support. */
+bool HPM_AddHook(enum HPluginHookType type, const char *target, void *hook, unsigned int pID) {
+	if( !HPM->hooking ) {
+		ShowError("HPM:AddHook Fail! '%s' tried to hook to '%s' but HPMHooking is disabled!\n",HPM->pid2name(pID),target);
+		return false;
+	}
+	/* search if target is a known hook point within 'common' */
+	/* if not check if a sub-hooking list is available (from the server) and run it by */
+	if( HPM->addhook_sub && HPM->addhook_sub(type,target,hook,pID) )
+		return true;
+	return false;
+}
+void HPM_HookStop (const char *func, unsigned int pID) {
+	/* track? */
+	HPM->force_return = true;
+}
+bool HPM_HookStopped (void) {
+	return HPM->force_return;
+}
 
 void hplugins_share_defaults(void) {
 	/* console */
@@ -447,6 +491,9 @@ void hplugins_share_defaults(void) {
 	HPM->share(hplugins_addToSession,"addToSession");
 	HPM->share(hplugins_getFromSession,"getFromSession");
 	HPM->share(hplugins_removeFromSession,"removeFromSession");
+	HPM->share(HPM_AddHook,"AddHook");
+	HPM->share(HPM_HookStop,"HookStop");
+	HPM->share(HPM_HookStopped,"HookStopped");
 	/* core */
 	HPM->share(&runflag,"runflag");
 	HPM->share(arg_v,"arg_v");
@@ -489,7 +536,7 @@ void hpm_init(void) {
 	HPMiMalloc->realloc = HPM_realloc;
 	HPMiMalloc->astrdup = HPM_astrdup;
 
-	sscanf(HPM_VERSION, "%d.%d", &HPM->version[0], &HPM->version[1]);
+	sscanf(HPM_VERSION, "%u.%u", &HPM->version[0], &HPM->version[1]);
 	
 	if( HPM->version[0] == 0 && HPM->version[1] == 0 ) {
 		ShowError("HPM:init:failed to retrieve HPM version!!\n");
@@ -554,6 +601,8 @@ void hpm_defaults(void) {
 	
 	HPM->fnames = NULL;
 	HPM->fnamec = 0;
+	HPM->force_return = false;
+	HPM->hooking = false;
 	
 	HPM->init = hpm_init;
 	HPM->final = hpm_final;
@@ -573,4 +622,5 @@ void hpm_defaults(void) {
 	HPM->pid2name = hplugins_id2name;
 	HPM->parse_packets = hplugins_parse_packets;
 	HPM->load_sub = NULL;
+	HPM->addhook_sub = NULL;
 }
diff --git a/src/common/HPM.h b/src/common/HPM.h
index 614498fd3..395555948 100644
--- a/src/common/HPM.h
+++ b/src/common/HPM.h
@@ -79,6 +79,9 @@ struct HPM_interface {
 	/* vars */
 	unsigned int version[2];
 	bool off;
+	bool hooking;
+	/* hooking */
+	bool force_return;
 	/* data */
 	struct hplugin **plugins;
 	unsigned int plugin_count;
@@ -94,12 +97,12 @@ struct HPM_interface {
 	void (*init) (void);
 	void (*final) (void);
 	struct hplugin * (*create) (void);
-	void (*load) (const char* filename);
+	struct hplugin * (*load) (const char* filename);
 	void (*unload) (struct hplugin* plugin);
 	bool (*exists) (const char *filename);
 	bool (*iscompatible) (char* version);
 	void (*event) (enum hp_event_types type);
-	void *(*import_symbol) (char *);
+	void *(*import_symbol) (char *name, unsigned int pID);
 	void (*share) (void *, char *);
 	void (*symbol_defaults) (void);
 	void (*config_read) (void);
@@ -108,6 +111,7 @@ struct HPM_interface {
 	char *(*pid2name) (unsigned int pid);
 	unsigned char (*parse_packets) (int fd, enum HPluginPacketHookingPoints point);
 	void (*load_sub) (struct hplugin *plugin);
+	bool (*addhook_sub) (enum HPluginHookType type, const char *target, void *hook, unsigned int pID);
 } HPM_s;
 
 struct HPM_interface *HPM;
diff --git a/src/common/HPMi.h b/src/common/HPMi.h
index c8bce8ee8..9c2a6184e 100644
--- a/src/common/HPMi.h
+++ b/src/common/HPMi.h
@@ -35,7 +35,7 @@ struct map_session_data;
 /* after */
 #include "../common/showmsg.h"
 
-#define HPM_VERSION "0.2"
+#define HPM_VERSION "1.0"
 
 struct hplugin_info {
 	char* name;
@@ -44,10 +44,10 @@ struct hplugin_info {
 	char* req_version;
 };
 
-HPExport void *(*import_symbol) (char *name);
+HPExport void *(*import_symbol) (char *name, unsigned int pID);
 HPExport Sql *mysql_handle;
 
-#define GET_SYMBOL(n) import_symbol(n)
+#define GET_SYMBOL(n) import_symbol(n,HPMi->pid)
 
 #define SERVER_TYPE_ALL SERVER_TYPE_LOGIN|SERVER_TYPE_CHAR|SERVER_TYPE_MAP
 
@@ -55,6 +55,7 @@ enum hp_event_types {
 	HPET_INIT,/* server starts */
 	HPET_FINAL,/* server is shutting down */
 	HPET_READY,/* server is ready (online) */
+	HPET_POST_FINAL,/* server is done shutting down */
 	HPET_MAX,
 };
 
@@ -70,6 +71,18 @@ enum HPluginPacketHookingPoints {
 	hpPHP_MAX,
 };
 
+enum HPluginHookType {
+	HOOK_TYPE_PRE,
+	HOOK_TYPE_POST,
+};
+
+#define addHookPre(tname,hook) HPMi->AddHook(HOOK_TYPE_PRE,tname,hook,HPMi->pid)
+#define addHookPost(tname,hook) HPMi->AddHook(HOOK_TYPE_POST,tname,hook,HPMi->pid)
+/* need better names ;/ */
+/* will not run the original function after pre-hook processing is complete (other hooks will run) */
+#define hookStop() HPMi->HookStop(__func__,HPMi->pid)
+#define hookStopped() HPMi->HookStopped()
+
 /* Hercules Plugin Mananger Include Interface */
 HPExport struct HPMi_interface {
 	/* */
@@ -89,6 +102,10 @@ HPExport struct HPMi_interface {
 	void (*removeFromSession) (struct socket_data *sess, unsigned int id, unsigned int type);
 	/* packet */
 	bool (*addPacket) (unsigned short cmd, unsigned short length, void (*receive)(int fd), unsigned int point, unsigned int pluginID);
+	/* Hooking */
+	bool (*AddHook) (enum HPluginHookType type, const char *target, void *hook, unsigned int pID);
+	void (*HookStop) (const char *func, unsigned int pID);
+	bool (*HookStopped) (void);
 } HPMi_s;
 #ifndef _HPM_H_
 HPExport struct HPMi_interface *HPMi;
diff --git a/src/map/HPMmap.c b/src/map/HPMmap.c
index 17d72bc98..3ba9ae725 100644
--- a/src/map/HPMmap.c
+++ b/src/map/HPMmap.c
@@ -10,12 +10,29 @@
 #include "pc.h"
 #include "map.h"
 
+//
+#include "chat.h"
+#include "chrif.h"
+#include "duel.h"
+#include "elemental.h"
+#include "homunculus.h"
+#include "instance.h"
+#include "intif.h"
+#include "irc-bot.h"
+#include "mail.h"
+#include "mapreg.h"
+#include "mercenary.h"
+#include "party.h"
+#include "pet.h"
+#include "quest.h"
+#include "storage.h"
+#include "trade.h"
+
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 
-
 void HPM_map_addToMSD(struct map_session_data *sd, void *data, unsigned int id, unsigned int type, bool autofree) {
 	struct HPluginData *HPData;
 	unsigned int i;
@@ -80,10 +97,10 @@ void HPM_map_removeFromMSD(struct map_session_data *sd, unsigned int id, unsigne
 	
 }
 void HPM_map_plugin_load_sub(struct hplugin *plugin) {
-	plugin->hpi->addCommand		= HPM->import_symbol("addCommand");
-	plugin->hpi->addScript		= HPM->import_symbol("addScript");
+	plugin->hpi->addCommand		= HPM->import_symbol("addCommand",plugin->idx);
+	plugin->hpi->addScript		= HPM->import_symbol("addScript",plugin->idx);
 	/* */
-	plugin->hpi->addToMSD		= HPM->import_symbol("addToMSD");
-	plugin->hpi->getFromMSD		= HPM->import_symbol("getFromMSD");
-	plugin->hpi->removeFromMSD	= HPM->import_symbol("removeFromMSD");
-}
+	plugin->hpi->addToMSD		= HPM->import_symbol("addToMSD",plugin->idx);
+	plugin->hpi->getFromMSD		= HPM->import_symbol("getFromMSD",plugin->idx);
+	plugin->hpi->removeFromMSD	= HPM->import_symbol("removeFromMSD",plugin->idx);
+}
\ No newline at end of file
diff --git a/src/map/battle.c b/src/map/battle.c
index 6e6e7eab5..c79dee7ee 100644
--- a/src/map/battle.c
+++ b/src/map/battle.c
@@ -410,8 +410,8 @@ int64 battle_attr_fix(struct block_list *src, struct block_list *target, int64 d
 	}
 	return damage*ratio/100;
 }
-#ifdef RENEWAL
 int64 battle_calc_weapon_damage(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, struct weapon_atk *watk, int nk, bool n_ele, short s_ele, short s_ele_, int size, int type, int flag, int flag2){ // [malufett]
+#ifdef RENEWAL
 	int64 damage, eatk = 0;
 	struct status_change *sc;
 	struct map_session_data *sd;
@@ -470,8 +470,10 @@ int64 battle_calc_weapon_damage(struct block_list *src, struct block_list *bl, u
 	damage = battle->calc_cardfix(BF_WEAPON, src, bl, nk, s_ele, s_ele_, damage, 0, flag2);
 
 	return damage;
-}
+#else
+	return 0;
 #endif
+}
 /*==========================================
  * Calculates the standard damage of a normal attack assuming it hits,
  * it calculates nothing extra fancy, is needed for magnum break's WATK_ELEMENT bonus. [Skotlex]
@@ -484,7 +486,7 @@ int64 battle_calc_weapon_damage(struct block_list *src, struct block_list *bl, u
  * &8: Skip target size adjustment (Extremity Fist?)
  *&16: Arrow attack but BOW, REVOLVER, RIFLE, SHOTGUN, GATLING or GRENADE type weapon not equipped (i.e. shuriken, kunai and venom knives not affected by DEX)
  */
-#ifdef RENEWAL
+/* 'battle_calc_base_damage' is used on renewal, 'battle_calc_base_damage2' otherwise. */
 int64 battle_calc_base_damage(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int nk, bool n_ele, short s_ele, short s_ele_, int type, int flag, int flag2) {
 	int64 damage, batk;
 	struct status_data *st = status->get_status_data(src);
@@ -495,8 +497,10 @@ int64 battle_calc_base_damage(struct block_list *src, struct block_list *bl, uin
 		damage = batk + 3 * battle->calc_weapon_damage(src, bl, skill_id, skill_lv, &st->lhw, nk, n_ele, s_ele, s_ele_, status_get_size(bl), type, flag, flag2) / 4;
 	else
 		damage = (batk << 1) + battle->calc_weapon_damage(src, bl, skill_id, skill_lv, &st->rhw, nk, n_ele, s_ele, s_ele_, status_get_size(bl), type, flag, flag2);
-#else
-static int64 battle_calc_base_damage(struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag) {
+	
+	return damage;
+}
+int64 battle_calc_base_damage2(struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag) {
 	unsigned int atkmin=0, atkmax=0;
 	short type = 0;
 	int64 damage = 0;
@@ -572,7 +576,6 @@ static int64 battle_calc_base_damage(struct status_data *st, struct weapon_atk *
 				damage += damage * sd->weapon_atk_rate[sd->weapontype1] / 100;
 		}
 	}
-#endif
 	return damage;
 }
 
@@ -856,10 +859,10 @@ int64 battle_calc_elefix(struct block_list *src, struct block_list *target, uint
 		sc = status->get_sc(src);
 
 		if( sc && sc->data[SC_SUB_WEAPONPROPERTY] ) { // Descriptions indicate this means adding a percent of a normal attack in another element. [Skotlex]
-			int64 temp = battle->calc_base_damage(sstatus, &sstatus->rhw, sc, tstatus->size, BL_CAST(BL_PC, src), (flag?2:0)) * sc->data[SC_SUB_WEAPONPROPERTY]->val2 / 100;
+			int64 temp = battle->calc_base_damage2(sstatus, &sstatus->rhw, sc, tstatus->size, BL_CAST(BL_PC, src), (flag?2:0)) * sc->data[SC_SUB_WEAPONPROPERTY]->val2 / 100;
 			damage += battle->attr_fix(src, target, temp, sc->data[SC_SUB_WEAPONPROPERTY]->val1, tstatus->def_ele, tstatus->ele_lv);
 			if( left ) {
-				temp = battle->calc_base_damage(sstatus, &sstatus->lhw, sc, tstatus->size, BL_CAST(BL_PC, src), (flag?2:0)) * sc->data[SC_SUB_WEAPONPROPERTY]->val2 / 100;
+				temp = battle->calc_base_damage2(sstatus, &sstatus->lhw, sc, tstatus->size, BL_CAST(BL_PC, src), (flag?2:0)) * sc->data[SC_SUB_WEAPONPROPERTY]->val2 / 100;
 				damage += battle->attr_fix(src, target, temp, sc->data[SC_SUB_WEAPONPROPERTY]->val1, tstatus->def_ele, tstatus->ele_lv);
 			}
 		}
@@ -4514,9 +4517,9 @@ struct Damage battle_calc_weapon_attack(struct block_list *src,struct block_list
 					wd.damage2 = battle->calc_masteryfix(src, target, skill_id, skill_lv, wd.damage2, wd.div_, 1, flag.weapon);
 				}
 #else
-				wd.damage = battle->calc_base_damage(sstatus, &sstatus->rhw, sc, tstatus->size, sd, i);
+				wd.damage = battle->calc_base_damage2(sstatus, &sstatus->rhw, sc, tstatus->size, sd, i);
 				if (flag.lh)
-					wd.damage2 = battle->calc_base_damage(sstatus, &sstatus->lhw, sc, tstatus->size, sd, i);
+					wd.damage2 = battle->calc_base_damage2(sstatus, &sstatus->lhw, sc, tstatus->size, sd, i);
 #endif
 				if (nk&NK_SPLASHSPLIT){ // Divide ATK among targets
 					if(wflag>0)
@@ -6784,9 +6787,7 @@ void battle_defaults(void) {
 	battle->calc_masteryfix = battle_calc_masteryfix;
 	battle->calc_skillratio = battle_calc_skillratio;
 	battle->calc_sizefix = battle_calc_sizefix;
-#ifdef RENEWAL
 	battle->calc_weapon_damage = battle_calc_weapon_damage;
-#endif
 	battle->calc_defense = battle_calc_defense;
 	battle->get_master = battle_get_master;
 	battle->get_targeted = battle_gettargeted;
@@ -6804,6 +6805,7 @@ void battle_defaults(void) {
 	battle->blewcount_bonus = battle_blewcount_bonus;
 	battle->range_type = battle_range_type;
 	battle->calc_base_damage = battle_calc_base_damage;
+	battle->calc_base_damage2 = battle_calc_base_damage2;
 	battle->calc_misc_attack = battle_calc_misc_attack;
 	battle->calc_magic_attack = battle_calc_magic_attack;
 	battle->adjust_skill_damage = battle_adjust_skill_damage;
diff --git a/src/map/battle.h b/src/map/battle.h
index 8878962b8..6d5d5f186 100644
--- a/src/map/battle.h
+++ b/src/map/battle.h
@@ -523,10 +523,8 @@ struct battle_interface {
 	int (*calc_skillratio) (int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int skillratio, int flag);
 	/* applies size modifiers */
 	int64 (*calc_sizefix) (struct map_session_data *sd, int64 damage, int type, int size,  bool ignore);
-#ifdef RENEWAL
 	/* get weapon damage */
 	int64 (*calc_weapon_damage) (struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, struct weapon_atk *watk, int nk, bool n_ele, short s_ele, short s_ele_, int size, int type, int flag, int flag2);
-#endif
 	/* applies defense reductions */
 	int64 (*calc_defense) (int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int flag, int pdef);
 	/* get master (who does this unit respond to?) */
@@ -554,12 +552,8 @@ struct battle_interface {
 	int (*blewcount_bonus) (struct map_session_data *sd, uint16 skill_id);
 	/* skill range criteria */
 	int (*range_type) (struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv);
-	int64 (*calc_base_damage)
-#ifdef RENEWAL
-		(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int nk, bool n_ele, short s_ele, short s_ele_, int type, int flag, int flag2);
-#else
-		(struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag);
-#endif
+	int64 (*calc_base_damage) (struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int nk, bool n_ele, short s_ele, short s_ele_, int type, int flag, int flag2);
+	int64 (*calc_base_damage2) (struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag);
 	struct Damage (*calc_misc_attack) (struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int mflag);
 	struct Damage (*calc_magic_attack) (struct block_list *src,struct block_list *target,uint16 skill_id,uint16 skill_lv,int mflag);
 	int (*adjust_skill_damage) (int m, unsigned short skill_id);
diff --git a/src/map/map.c b/src/map/map.c
index 0457de5bb..0c684542d 100644
--- a/src/map/map.c
+++ b/src/map/map.c
@@ -5016,8 +5016,10 @@ void do_final(void)
 	struct s_mapiterator* iter;
 
 	ShowStatus("Terminating...\n");
+	
 	hChSys.closing = true;
 	HPM->event(HPET_FINAL);
+	
 	if (map->cpsd) aFree(map->cpsd);
 
 	//Ladies and babies first.
@@ -5090,6 +5092,8 @@ void do_final(void)
 	if( !map->enable_grf )
 		aFree(map->cache_buffer);
 
+	HPM->event(HPET_POST_FINAL);
+	
 	ShowStatus("Finished.\n");
 }
 
@@ -5263,6 +5267,7 @@ void map_hp_symbols(void) {
 	HPM->share(itemdb,"itemdb");
 	HPM->share(logs,"logs");
 	HPM->share(mail,"mail");
+	HPM->share(instance,"instance");
 	HPM->share(script,"script");
 	HPM->share(searchstore,"searchstore");
 	HPM->share(skill,"skill");
diff --git a/src/map/pc.c b/src/map/pc.c
index 58972a204..6b7d6c735 100644
--- a/src/map/pc.c
+++ b/src/map/pc.c
@@ -9460,13 +9460,12 @@ int pc_del_charm(struct map_session_data *sd,int count,int type)
 	clif->charm(sd, type);
 	return 0;
 }
-#if defined(RENEWAL_DROP) || defined(RENEWAL_EXP)
 /*==========================================
  * Renewal EXP/Itemdrop rate modifier base on level penalty
  * 1=exp 2=itemdrop
  *------------------------------------------*/
-int pc_level_penalty_mod(int diff, unsigned char race, unsigned short mode, int type)
-{
+int pc_level_penalty_mod(int diff, unsigned char race, unsigned short mode, int type) {
+#if defined(RENEWAL_DROP) || defined(RENEWAL_EXP)
 	int rate = 100, i;
 
 	if( diff < 0 )
@@ -9489,8 +9488,10 @@ int pc_level_penalty_mod(int diff, unsigned char race, unsigned short mode, int
 	}
 
 	return rate;
-}
+#else
+	return 100;
 #endif
+}
 int pc_split_str(char *str,char **val,int num)
 {
 	int i;
@@ -9810,8 +9811,8 @@ void pc_read_skill_tree(void) {
         clif->skillinfoblock(sd);
     mapit->free(iter);
 }
-#if defined(RENEWAL_DROP) || defined(RENEWAL_EXP)
 bool pc_readdb_levelpenalty(char* fields[], int columns, int current) {
+#if defined(RENEWAL_DROP) || defined(RENEWAL_EXP)
 	int type, race, diff;
 
 	type = atoi(fields[0]);
@@ -9834,10 +9835,9 @@ bool pc_readdb_levelpenalty(char* fields[], int columns, int current) {
 		diff = min(MAX_LEVEL + ( ~(diff) + 1 ), MAX_LEVEL*2);
 
 	pc->level_penalty[type][race][diff] = atoi(fields[3]);
-
+#endif
 	return true;
 }
-#endif
 
 /*==========================================
  * pc DB reading.
@@ -10371,9 +10371,7 @@ void pc_defaults(void) {
 	pc->del_charm = pc_del_charm;
 	
 	pc->baselevelchanged = pc_baselevelchanged;
-#if defined(RENEWAL_DROP) || defined(RENEWAL_EXP)
 	pc->level_penalty_mod = pc_level_penalty_mod;
-#endif
 	
 	pc->calc_skillpoint = pc_calc_skillpoint;
 	
@@ -10395,9 +10393,7 @@ void pc_defaults(void) {
 	pc->eventtimer = pc_eventtimer;
 	pc->daynight_timer_sub = pc_daynight_timer_sub;
 	pc->charm_timer = pc_charm_timer;
-#if defined(RENEWAL_DROP) || defined(RENEWAL_EXP)
 	pc->readdb_levelpenalty = pc_readdb_levelpenalty;
-#endif
 	pc->autosave = pc_autosave;
 	pc->follow_timer = pc_follow_timer;
 	pc->read_skill_tree = pc_read_skill_tree;
diff --git a/src/map/pc.h b/src/map/pc.h
index bf2f9d7c5..fadb922b5 100644
--- a/src/map/pc.h
+++ b/src/map/pc.h
@@ -931,9 +931,7 @@ struct pc_interface {
 	int (*del_charm) (struct map_session_data *sd,int count,int type);
 	
 	void (*baselevelchanged) (struct map_session_data *sd);
-#if defined(RENEWAL_DROP) || defined(RENEWAL_EXP)
 	int (*level_penalty_mod) (int diff, unsigned char race, unsigned short mode, int type);
-#endif
 	int (*calc_skillpoint) (struct map_session_data* sd);
 	
 	int (*invincible_timer) (int tid, unsigned int tick, int id, intptr_t data);
@@ -954,9 +952,7 @@ struct pc_interface {
 	int (*eventtimer) (int tid, unsigned int tick, int id, intptr_t data);
 	int (*daynight_timer_sub) (struct map_session_data *sd,va_list ap);
 	int (*charm_timer) (int tid, unsigned int tick, int id, intptr_t data);
-#if defined(RENEWAL_DROP) || defined(RENEWAL_EXP)
 	bool (*readdb_levelpenalty) (char* fields[], int columns, int current);
-#endif
 	int (*autosave) (int tid, unsigned int tick, int id, intptr_t data);
 	int (*follow_timer) (int tid, unsigned int tick, int id, intptr_t data);
 	void (*read_skill_tree) (void);
diff --git a/src/map/skill.c b/src/map/skill.c
index dd87f27d9..f359e81d4 100644
--- a/src/map/skill.c
+++ b/src/map/skill.c
@@ -185,9 +185,13 @@ int	skill_get_unit_bl_target( uint16 skill_id )    { skill_get (skill->db[skill_
 int	skill_get_unit_flag( uint16 skill_id )         { skill_get (skill->db[skill_id].unit_flag, skill_id); }
 int	skill_get_unit_layout_type( uint16 skill_id ,uint16 skill_lv ){ skill_get2 (skill->db[skill_id].unit_layout_type[skill_glv(skill_lv-1)], skill_id, skill_lv); }
 int	skill_get_cooldown( uint16 skill_id, uint16 skill_lv )     { skill_get2 (skill->db[skill_id].cooldown[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+int	skill_get_fixed_cast( uint16 skill_id ,uint16 skill_lv ) {
 #ifdef RENEWAL_CAST
-int	skill_get_fixed_cast( uint16 skill_id ,uint16 skill_lv ){ skill_get2 (skill->db[skill_id].fixed_cast[skill_glv(skill_lv-1)], skill_id, skill_lv); }
+	skill_get2 (skill->db[skill_id].fixed_cast[skill_glv(skill_lv-1)], skill_id, skill_lv);
+#else
+	return 0;
 #endif
+}
 int skill_tree_get_max(uint16 skill_id, int b_class)
 {
 	int i;
@@ -13792,8 +13796,8 @@ int skill_castfix_sc (struct block_list *bl, int time) {
 	//ShowInfo("Castime castfix_sc = %d\n",time);
 	return time;
 }
-#ifdef RENEWAL_CAST
 int skill_vfcastfix(struct block_list *bl, double time, uint16 skill_id, uint16 skill_lv) {
+#ifdef RENEWAL_CAST
 	struct status_change *sc = status->get_sc(bl);
 	struct map_session_data *sd = BL_CAST(BL_PC,bl);
 	int fixed = skill->get_fixed_cast(skill_id, skill_lv), fixcast_r = 0, varcast_r = 0, i = 0;
@@ -13907,10 +13911,9 @@ int skill_vfcastfix(struct block_list *bl, double time, uint16 skill_id, uint16
 		time = (1 - sqrt( ((float)(status_get_dex(bl)*2 + status_get_int(bl)) / battle_config.vcast_stat_scale) )) * time;
 	// underflow checking/capping
 	time = max(time, 0) + (1 - (float)min(fixcast_r, 100) / 100) * max(fixed,0);
-
+#endif
 	return (int)time;
 }
-#endif
 
 /*==========================================
  * Does delay reductions based on dex/agi, sc data, item bonuses, ...
@@ -18156,9 +18159,7 @@ void skill_defaults(void) {
 	skill->unit_ondamaged = skill_unit_ondamaged;
 	skill->cast_fix = skill_castfix;
 	skill->cast_fix_sc = skill_castfix_sc;	
-#ifdef RENEWAL_CAST
 	skill->vf_cast_fix = skill_vfcastfix;
-#endif
 	skill->delay_fix = skill_delay_fix;
 	skill->check_condition_castbegin = skill_check_condition_castbegin;
 	skill->check_condition_castend = skill_check_condition_castend;
@@ -18222,9 +18223,7 @@ void skill_defaults(void) {
 	skill->check_condition_mob_master_sub = skill_check_condition_mob_master_sub;
 	skill->brandishspear_first = skill_brandishspear_first;
 	skill->brandishspear_dir = skill_brandishspear_dir;
-#ifdef RENEWAL_CAST
 	skill->get_fixed_cast = skill_get_fixed_cast;
-#endif
 	skill->sit_count = skill_sit_count;
 	skill->sit_in = skill_sit_in;
 	skill->sit_out = skill_sit_out;
diff --git a/src/map/skill.h b/src/map/skill.h
index d2546c706..592721f1e 100644
--- a/src/map/skill.h
+++ b/src/map/skill.h
@@ -1893,9 +1893,7 @@ struct skill_interface {
 	int (*unit_ondamaged) (struct skill_unit *src,struct block_list *bl,int64 damage,unsigned int tick);
 	int (*cast_fix) ( struct block_list *bl, uint16 skill_id, uint16 skill_lv);
 	int (*cast_fix_sc) ( struct block_list *bl, int time);
-#ifdef RENEWAL_CAST
 	int (*vf_cast_fix) ( struct block_list *bl, double time, uint16 skill_id, uint16 skill_lv);
-#endif
 	int (*delay_fix) ( struct block_list *bl, uint16 skill_id, uint16 skill_lv);
 	int (*check_condition_castbegin) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
 	int (*check_condition_castend) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
@@ -1959,9 +1957,7 @@ struct skill_interface {
 	int (*check_condition_mob_master_sub) (struct block_list *bl, va_list ap);
 	void (*brandishspear_first) (struct square *tc, uint8 dir, int16 x, int16 y);
 	void (*brandishspear_dir) (struct square* tc, uint8 dir, int are);
-#ifdef RENEWAL_CAST
 	int	(*get_fixed_cast) ( uint16 skill_id ,uint16 skill_lv );
-#endif
 	int (*sit_count) (struct block_list *bl, va_list ap);
 	int (*sit_in) (struct block_list *bl, va_list ap);
 	int (*sit_out) (struct block_list *bl, va_list ap);
diff --git a/src/plugins/HPMHooking.c b/src/plugins/HPMHooking.c
new file mode 100644
index 000000000..8b4f06ae0
--- /dev/null
+++ b/src/plugins/HPMHooking.c
@@ -0,0 +1,173 @@
+// Copyright (c) Hercules Dev Team, licensed under GNU GPL.
+// See the LICENSE file
+// Sample Hercules Plugin
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+
+#include "../common/HPMi.h"
+#include "../common/mmo.h"
+#include "../common/socket.h"
+#include "../common/malloc.h"
+#include "../common/db.h"
+
+#include "../map/map.h"
+#include "../map/path.h"
+#include "../map/chrif.h"
+#include "../map/clif.h"
+#include "../map/duel.h"
+#include "../map/intif.h"
+#include "../map/npc.h"
+#include "../map/pc.h"
+#include "../map/status.h"
+#include "../map/mob.h"
+#include "../map/npc.h"
+#include "../map/chat.h"
+#include "../map/itemdb.h"
+#include "../map/storage.h"
+#include "../map/skill.h"
+#include "../map/trade.h"
+#include "../map/party.h"
+#include "../map/unit.h"
+#include "../map/battle.h"
+#include "../map/battleground.h"
+#include "../map/quest.h"
+#include "../map/script.h"
+#include "../map/mapreg.h"
+#include "../map/guild.h"
+#include "../map/pet.h"
+#include "../map/homunculus.h"
+#include "../map/instance.h"
+#include "../map/mercenary.h"
+#include "../map/elemental.h"
+#include "../map/atcommand.h"
+#include "../map/log.h"
+#include "../map/mail.h"
+#include "../map/irc-bot.h"
+
+HPExport struct hplugin_info pinfo = {
+	"HPMHooking",   // Plugin name
+	SERVER_TYPE_MAP,// Which server types this plugin works with?
+	"0.1",          // Plugin version
+	HPM_VERSION,    // HPM Version (don't change, macro is automatically updated)
+};
+
+#define HP_POP(x) #x , (void**)(&x)
+#define HP_POP2(x) (void*)x
+DBMap *hp_db;/* hooking points db -- for quick lookup */
+
+struct HookingPointData {
+	char* name;
+	void **sref;
+	void *tref;
+	int idx;
+};
+
+struct HPMHookPoint {
+	void *func;
+	unsigned int pID;
+};
+
+struct HPMHooksCore {
+	#include "../plugins/HPMHooking/HPMHooking.HPMHooksCore.inc"
+	struct {
+		int total;
+	} data;
+} HPMHooks;
+
+bool *HPMforce_return;
+
+void HPM_HP_final(void);
+void HPM_HP_load(void);
+
+HPExport void server_post_final (void) {
+	HPM_HP_final();
+}
+
+HPExport bool Hooked (bool *fr) {
+	HPMforce_return = fr;
+	DB = GET_SYMBOL("DB");
+	iMalloc = GET_SYMBOL("iMalloc");
+#include "../plugins/HPMHooking/HPMHooking.GetSymbol.inc"
+	HPM_HP_load();
+	return true;
+}
+
+
+HPExport bool HPM_Plugin_AddHook(enum HPluginHookType type, const char *target, void *hook, unsigned int pID) {
+	struct HookingPointData *hpd;
+	
+	if( hp_db && (hpd = strdb_get(hp_db,target)) ) {
+		struct HPMHookPoint **hp = NULL;
+		int *count = NULL;
+		
+		if( type == HOOK_TYPE_PRE ) {
+			hp = (struct HPMHookPoint **)((char *)&HPMHooks.list + (sizeof(struct HPMHookPoint *)*hpd->idx));
+			count = (int *)((char *)&HPMHooks.count + (sizeof(int)*hpd->idx));
+		} else {
+			hp = (struct HPMHookPoint **)((char *)&HPMHooks.list + (sizeof(struct HPMHookPoint *)*(hpd->idx+1)));
+			count = (int *)((char *)&HPMHooks.count + (sizeof(int)*(hpd->idx+1)));
+		}
+		
+		if( hp ) {
+			*count += 1;
+			
+			RECREATE(*hp, struct HPMHookPoint, *count);
+			
+			(*hp)[*count - 1].func = hook;
+			(*hp)[*count - 1].pID = pID;
+			
+			*(hpd->sref) = hpd->tref;
+			
+			return true;
+		}
+	}
+	
+	return false;
+}
+
+#include "../plugins/HPMHooking/HPMHooking.Hooks.inc"
+
+void HPM_HP_final(void) {
+	int i, len = HPMHooks.data.total * 2;
+	
+	if( hp_db )
+		db_destroy(hp_db);
+	
+	for(i = 0; i < len; i++) {
+		int *count = (int *)((char *)&HPMHooks.count + (sizeof(int)*(i)));
+		
+		if( count && *count ) {
+			struct HPMHookPoint **hp = (struct HPMHookPoint **)((char *)&HPMHooks.list + (sizeof(struct HPMHookPoint *)*(i)));
+			
+			if( hp && *hp )
+				aFree(*hp);
+		}
+	}
+	
+}
+
+void HPM_HP_load(void) {
+	#include "../plugins/HPMHooking/HPMHooking.HookingPoints.inc"
+	int i, len = ARRAYLENGTH(HookingPoints);
+	
+	memset(&HPMHooks,0,sizeof(struct HPMHooksCore));
+	
+	hp_db = strdb_alloc(DB_OPT_BASE|DB_OPT_DUP_KEY|DB_OPT_RELEASE_DATA, HookingPointsLenMax);
+	
+	for(i = 0; i < len; i++) {
+		struct HookingPointData *hpd = NULL;
+		
+		CREATE(hpd, struct HookingPointData, 1);
+		
+		memcpy(hpd, &HookingPoints[i], sizeof(struct HookingPointData));
+		
+		strdb_put(hp_db, HookingPoints[i].name, hpd);
+		
+		HPMHooks.data.total++;
+	}
+	
+	#include "../plugins/HPMHooking/HPMHooking.sources.inc"
+}
+
diff --git a/src/plugins/HPMHooking/HPMHooking.GetSymbol.inc b/src/plugins/HPMHooking/HPMHooking.GetSymbol.inc
new file mode 100644
index 000000000..5caceb75a
--- /dev/null
+++ b/src/plugins/HPMHooking/HPMHooking.GetSymbol.inc
@@ -0,0 +1,37 @@
+if( !(atcommand = GET_SYMBOL("atcommand") ) ) return false;
+if( !(battle = GET_SYMBOL("battle") ) ) return false;
+if( !(bg = GET_SYMBOL("battlegrounds") ) ) return false;
+if( !(buyingstore = GET_SYMBOL("buyingstore") ) ) return false;
+if( !(chat = GET_SYMBOL("chat") ) ) return false;
+if( !(chrif = GET_SYMBOL("chrif") ) ) return false;
+if( !(clif = GET_SYMBOL("clif") ) ) return false;
+if( !(duel = GET_SYMBOL("duel") ) ) return false;
+if( !(elemental = GET_SYMBOL("elemental") ) ) return false;
+if( !(guild = GET_SYMBOL("guild") ) ) return false;
+if( !(gstorage = GET_SYMBOL("gstorage") ) ) return false;
+if( !(homun = GET_SYMBOL("homun") ) ) return false;
+if( !(instance = GET_SYMBOL("instance") ) ) return false;
+if( !(intif = GET_SYMBOL("intif") ) ) return false;
+if( !(ircbot = GET_SYMBOL("ircbot") ) ) return false;
+if( !(itemdb = GET_SYMBOL("itemdb") ) ) return false;
+if( !(logs = GET_SYMBOL("logs") ) ) return false;
+if( !(mail = GET_SYMBOL("mail") ) ) return false;
+if( !(map = GET_SYMBOL("map") ) ) return false;
+if( !(mapit = GET_SYMBOL("mapit") ) ) return false;
+if( !(mapreg = GET_SYMBOL("mapreg") ) ) return false;
+if( !(mercenary = GET_SYMBOL("mercenary") ) ) return false;
+if( !(mob = GET_SYMBOL("mob") ) ) return false;
+if( !(npc = GET_SYMBOL("npc") ) ) return false;
+if( !(party = GET_SYMBOL("party") ) ) return false;
+if( !(path = GET_SYMBOL("path") ) ) return false;
+if( !(pc = GET_SYMBOL("pc") ) ) return false;
+if( !(pet = GET_SYMBOL("pet") ) ) return false;
+if( !(quest = GET_SYMBOL("quest") ) ) return false;
+if( !(script = GET_SYMBOL("script") ) ) return false;
+if( !(searchstore = GET_SYMBOL("searchstore") ) ) return false;
+if( !(skill = GET_SYMBOL("skill") ) ) return false;
+if( !(status = GET_SYMBOL("status") ) ) return false;
+if( !(storage = GET_SYMBOL("storage") ) ) return false;
+if( !(trade = GET_SYMBOL("trade") ) ) return false;
+if( !(unit = GET_SYMBOL("unit") ) ) return false;
+if( !(vending = GET_SYMBOL("vending") ) ) return false;
diff --git a/src/plugins/HPMHooking/HPMHooking.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking.HPMHooksCore.inc
new file mode 100644
index 000000000..c73747a10
--- /dev/null
+++ b/src/plugins/HPMHooking/HPMHooking.HPMHooksCore.inc
@@ -0,0 +1,9663 @@
+struct {
+struct HPMHookPoint *HP_atcommand_init_pre;
+struct HPMHookPoint *HP_atcommand_init_post;
+struct HPMHookPoint *HP_atcommand_final_pre;
+struct HPMHookPoint *HP_atcommand_final_post;
+struct HPMHookPoint *HP_atcommand_parse_pre;
+struct HPMHookPoint *HP_atcommand_parse_post;
+struct HPMHookPoint *HP_atcommand_create_pre;
+struct HPMHookPoint *HP_atcommand_create_post;
+struct HPMHookPoint *HP_atcommand_can_use_pre;
+struct HPMHookPoint *HP_atcommand_can_use_post;
+struct HPMHookPoint *HP_atcommand_can_use2_pre;
+struct HPMHookPoint *HP_atcommand_can_use2_post;
+struct HPMHookPoint *HP_atcommand_load_groups_pre;
+struct HPMHookPoint *HP_atcommand_load_groups_post;
+struct HPMHookPoint *HP_atcommand_exists_pre;
+struct HPMHookPoint *HP_atcommand_exists_post;
+struct HPMHookPoint *HP_atcommand_msg_read_pre;
+struct HPMHookPoint *HP_atcommand_msg_read_post;
+struct HPMHookPoint *HP_atcommand_final_msg_pre;
+struct HPMHookPoint *HP_atcommand_final_msg_post;
+struct HPMHookPoint *HP_atcommand_get_bind_byname_pre;
+struct HPMHookPoint *HP_atcommand_get_bind_byname_post;
+struct HPMHookPoint *HP_atcommand_get_info_byname_pre;
+struct HPMHookPoint *HP_atcommand_get_info_byname_post;
+struct HPMHookPoint *HP_atcommand_check_alias_pre;
+struct HPMHookPoint *HP_atcommand_check_alias_post;
+struct HPMHookPoint *HP_atcommand_get_suggestions_pre;
+struct HPMHookPoint *HP_atcommand_get_suggestions_post;
+struct HPMHookPoint *HP_atcommand_config_read_pre;
+struct HPMHookPoint *HP_atcommand_config_read_post;
+struct HPMHookPoint *HP_atcommand_stopattack_pre;
+struct HPMHookPoint *HP_atcommand_stopattack_post;
+struct HPMHookPoint *HP_atcommand_pvpoff_sub_pre;
+struct HPMHookPoint *HP_atcommand_pvpoff_sub_post;
+struct HPMHookPoint *HP_atcommand_pvpon_sub_pre;
+struct HPMHookPoint *HP_atcommand_pvpon_sub_post;
+struct HPMHookPoint *HP_atcommand_atkillmonster_sub_pre;
+struct HPMHookPoint *HP_atcommand_atkillmonster_sub_post;
+struct HPMHookPoint *HP_atcommand_raise_sub_pre;
+struct HPMHookPoint *HP_atcommand_raise_sub_post;
+struct HPMHookPoint *HP_atcommand_get_jail_time_pre;
+struct HPMHookPoint *HP_atcommand_get_jail_time_post;
+struct HPMHookPoint *HP_atcommand_cleanfloor_sub_pre;
+struct HPMHookPoint *HP_atcommand_cleanfloor_sub_post;
+struct HPMHookPoint *HP_atcommand_mutearea_sub_pre;
+struct HPMHookPoint *HP_atcommand_mutearea_sub_post;
+struct HPMHookPoint *HP_atcommand_commands_sub_pre;
+struct HPMHookPoint *HP_atcommand_commands_sub_post;
+struct HPMHookPoint *HP_atcommand_cmd_db_clear_pre;
+struct HPMHookPoint *HP_atcommand_cmd_db_clear_post;
+struct HPMHookPoint *HP_atcommand_cmd_db_clear_sub_pre;
+struct HPMHookPoint *HP_atcommand_cmd_db_clear_sub_post;
+struct HPMHookPoint *HP_atcommand_doload_pre;
+struct HPMHookPoint *HP_atcommand_doload_post;
+struct HPMHookPoint *HP_atcommand_base_commands_pre;
+struct HPMHookPoint *HP_atcommand_base_commands_post;
+struct HPMHookPoint *HP_battle_init_pre;
+struct HPMHookPoint *HP_battle_init_post;
+struct HPMHookPoint *HP_battle_final_pre;
+struct HPMHookPoint *HP_battle_final_post;
+struct HPMHookPoint *HP_battle_calc_attack_pre;
+struct HPMHookPoint *HP_battle_calc_attack_post;
+struct HPMHookPoint *HP_battle_calc_damage_pre;
+struct HPMHookPoint *HP_battle_calc_damage_post;
+struct HPMHookPoint *HP_battle_calc_gvg_damage_pre;
+struct HPMHookPoint *HP_battle_calc_gvg_damage_post;
+struct HPMHookPoint *HP_battle_calc_bg_damage_pre;
+struct HPMHookPoint *HP_battle_calc_bg_damage_post;
+struct HPMHookPoint *HP_battle_weapon_attack_pre;
+struct HPMHookPoint *HP_battle_weapon_attack_post;
+struct HPMHookPoint *HP_battle_calc_weapon_attack_pre;
+struct HPMHookPoint *HP_battle_calc_weapon_attack_post;
+struct HPMHookPoint *HP_battle_delay_damage_pre;
+struct HPMHookPoint *HP_battle_delay_damage_post;
+struct HPMHookPoint *HP_battle_drain_pre;
+struct HPMHookPoint *HP_battle_drain_post;
+struct HPMHookPoint *HP_battle_calc_return_damage_pre;
+struct HPMHookPoint *HP_battle_calc_return_damage_post;
+struct HPMHookPoint *HP_battle_attr_ratio_pre;
+struct HPMHookPoint *HP_battle_attr_ratio_post;
+struct HPMHookPoint *HP_battle_attr_fix_pre;
+struct HPMHookPoint *HP_battle_attr_fix_post;
+struct HPMHookPoint *HP_battle_calc_cardfix_pre;
+struct HPMHookPoint *HP_battle_calc_cardfix_post;
+struct HPMHookPoint *HP_battle_calc_elefix_pre;
+struct HPMHookPoint *HP_battle_calc_elefix_post;
+struct HPMHookPoint *HP_battle_calc_masteryfix_pre;
+struct HPMHookPoint *HP_battle_calc_masteryfix_post;
+struct HPMHookPoint *HP_battle_calc_skillratio_pre;
+struct HPMHookPoint *HP_battle_calc_skillratio_post;
+struct HPMHookPoint *HP_battle_calc_sizefix_pre;
+struct HPMHookPoint *HP_battle_calc_sizefix_post;
+struct HPMHookPoint *HP_battle_calc_weapon_damage_pre;
+struct HPMHookPoint *HP_battle_calc_weapon_damage_post;
+struct HPMHookPoint *HP_battle_calc_defense_pre;
+struct HPMHookPoint *HP_battle_calc_defense_post;
+struct HPMHookPoint *HP_battle_get_master_pre;
+struct HPMHookPoint *HP_battle_get_master_post;
+struct HPMHookPoint *HP_battle_get_targeted_pre;
+struct HPMHookPoint *HP_battle_get_targeted_post;
+struct HPMHookPoint *HP_battle_get_enemy_pre;
+struct HPMHookPoint *HP_battle_get_enemy_post;
+struct HPMHookPoint *HP_battle_get_target_pre;
+struct HPMHookPoint *HP_battle_get_target_post;
+struct HPMHookPoint *HP_battle_get_current_skill_pre;
+struct HPMHookPoint *HP_battle_get_current_skill_post;
+struct HPMHookPoint *HP_battle_check_undead_pre;
+struct HPMHookPoint *HP_battle_check_undead_post;
+struct HPMHookPoint *HP_battle_check_target_pre;
+struct HPMHookPoint *HP_battle_check_target_post;
+struct HPMHookPoint *HP_battle_check_range_pre;
+struct HPMHookPoint *HP_battle_check_range_post;
+struct HPMHookPoint *HP_battle_consume_ammo_pre;
+struct HPMHookPoint *HP_battle_consume_ammo_post;
+struct HPMHookPoint *HP_battle_get_targeted_sub_pre;
+struct HPMHookPoint *HP_battle_get_targeted_sub_post;
+struct HPMHookPoint *HP_battle_get_enemy_sub_pre;
+struct HPMHookPoint *HP_battle_get_enemy_sub_post;
+struct HPMHookPoint *HP_battle_get_enemy_area_sub_pre;
+struct HPMHookPoint *HP_battle_get_enemy_area_sub_post;
+struct HPMHookPoint *HP_battle_delay_damage_sub_pre;
+struct HPMHookPoint *HP_battle_delay_damage_sub_post;
+struct HPMHookPoint *HP_battle_blewcount_bonus_pre;
+struct HPMHookPoint *HP_battle_blewcount_bonus_post;
+struct HPMHookPoint *HP_battle_range_type_pre;
+struct HPMHookPoint *HP_battle_range_type_post;
+struct HPMHookPoint *HP_battle_calc_base_damage_pre;
+struct HPMHookPoint *HP_battle_calc_base_damage_post;
+struct HPMHookPoint *HP_battle_calc_base_damage2_pre;
+struct HPMHookPoint *HP_battle_calc_base_damage2_post;
+struct HPMHookPoint *HP_battle_calc_misc_attack_pre;
+struct HPMHookPoint *HP_battle_calc_misc_attack_post;
+struct HPMHookPoint *HP_battle_calc_magic_attack_pre;
+struct HPMHookPoint *HP_battle_calc_magic_attack_post;
+struct HPMHookPoint *HP_battle_adjust_skill_damage_pre;
+struct HPMHookPoint *HP_battle_adjust_skill_damage_post;
+struct HPMHookPoint *HP_battle_add_mastery_pre;
+struct HPMHookPoint *HP_battle_add_mastery_post;
+struct HPMHookPoint *HP_battle_calc_drain_pre;
+struct HPMHookPoint *HP_battle_calc_drain_post;
+struct HPMHookPoint *HP_battle_config_read_pre;
+struct HPMHookPoint *HP_battle_config_read_post;
+struct HPMHookPoint *HP_battle_config_set_defaults_pre;
+struct HPMHookPoint *HP_battle_config_set_defaults_post;
+struct HPMHookPoint *HP_battle_config_set_value_pre;
+struct HPMHookPoint *HP_battle_config_set_value_post;
+struct HPMHookPoint *HP_battle_config_get_value_pre;
+struct HPMHookPoint *HP_battle_config_get_value_post;
+struct HPMHookPoint *HP_battle_config_adjust_pre;
+struct HPMHookPoint *HP_battle_config_adjust_post;
+struct HPMHookPoint *HP_battle_get_enemy_area_pre;
+struct HPMHookPoint *HP_battle_get_enemy_area_post;
+struct HPMHookPoint *HP_battle_damage_area_pre;
+struct HPMHookPoint *HP_battle_damage_area_post;
+struct HPMHookPoint *HP_bg_init_pre;
+struct HPMHookPoint *HP_bg_init_post;
+struct HPMHookPoint *HP_bg_final_pre;
+struct HPMHookPoint *HP_bg_final_post;
+struct HPMHookPoint *HP_bg_name2arena_pre;
+struct HPMHookPoint *HP_bg_name2arena_post;
+struct HPMHookPoint *HP_bg_queue_add_pre;
+struct HPMHookPoint *HP_bg_queue_add_post;
+struct HPMHookPoint *HP_bg_can_queue_pre;
+struct HPMHookPoint *HP_bg_can_queue_post;
+struct HPMHookPoint *HP_bg_id2pos_pre;
+struct HPMHookPoint *HP_bg_id2pos_post;
+struct HPMHookPoint *HP_bg_queue_pc_cleanup_pre;
+struct HPMHookPoint *HP_bg_queue_pc_cleanup_post;
+struct HPMHookPoint *HP_bg_begin_pre;
+struct HPMHookPoint *HP_bg_begin_post;
+struct HPMHookPoint *HP_bg_begin_timer_pre;
+struct HPMHookPoint *HP_bg_begin_timer_post;
+struct HPMHookPoint *HP_bg_queue_pregame_pre;
+struct HPMHookPoint *HP_bg_queue_pregame_post;
+struct HPMHookPoint *HP_bg_fillup_timer_pre;
+struct HPMHookPoint *HP_bg_fillup_timer_post;
+struct HPMHookPoint *HP_bg_queue_ready_ack_pre;
+struct HPMHookPoint *HP_bg_queue_ready_ack_post;
+struct HPMHookPoint *HP_bg_match_over_pre;
+struct HPMHookPoint *HP_bg_match_over_post;
+struct HPMHookPoint *HP_bg_queue_check_pre;
+struct HPMHookPoint *HP_bg_queue_check_post;
+struct HPMHookPoint *HP_bg_team_search_pre;
+struct HPMHookPoint *HP_bg_team_search_post;
+struct HPMHookPoint *HP_bg_getavailablesd_pre;
+struct HPMHookPoint *HP_bg_getavailablesd_post;
+struct HPMHookPoint *HP_bg_team_delete_pre;
+struct HPMHookPoint *HP_bg_team_delete_post;
+struct HPMHookPoint *HP_bg_team_warp_pre;
+struct HPMHookPoint *HP_bg_team_warp_post;
+struct HPMHookPoint *HP_bg_send_dot_remove_pre;
+struct HPMHookPoint *HP_bg_send_dot_remove_post;
+struct HPMHookPoint *HP_bg_team_join_pre;
+struct HPMHookPoint *HP_bg_team_join_post;
+struct HPMHookPoint *HP_bg_team_leave_pre;
+struct HPMHookPoint *HP_bg_team_leave_post;
+struct HPMHookPoint *HP_bg_member_respawn_pre;
+struct HPMHookPoint *HP_bg_member_respawn_post;
+struct HPMHookPoint *HP_bg_create_pre;
+struct HPMHookPoint *HP_bg_create_post;
+struct HPMHookPoint *HP_bg_team_get_id_pre;
+struct HPMHookPoint *HP_bg_team_get_id_post;
+struct HPMHookPoint *HP_bg_send_message_pre;
+struct HPMHookPoint *HP_bg_send_message_post;
+struct HPMHookPoint *HP_bg_send_xy_timer_sub_pre;
+struct HPMHookPoint *HP_bg_send_xy_timer_sub_post;
+struct HPMHookPoint *HP_bg_send_xy_timer_pre;
+struct HPMHookPoint *HP_bg_send_xy_timer_post;
+struct HPMHookPoint *HP_bg_config_read_pre;
+struct HPMHookPoint *HP_bg_config_read_post;
+struct HPMHookPoint *HP_buyingstore_setup_pre;
+struct HPMHookPoint *HP_buyingstore_setup_post;
+struct HPMHookPoint *HP_buyingstore_create_pre;
+struct HPMHookPoint *HP_buyingstore_create_post;
+struct HPMHookPoint *HP_buyingstore_close_pre;
+struct HPMHookPoint *HP_buyingstore_close_post;
+struct HPMHookPoint *HP_buyingstore_open_pre;
+struct HPMHookPoint *HP_buyingstore_open_post;
+struct HPMHookPoint *HP_buyingstore_trade_pre;
+struct HPMHookPoint *HP_buyingstore_trade_post;
+struct HPMHookPoint *HP_buyingstore_search_pre;
+struct HPMHookPoint *HP_buyingstore_search_post;
+struct HPMHookPoint *HP_buyingstore_searchall_pre;
+struct HPMHookPoint *HP_buyingstore_searchall_post;
+struct HPMHookPoint *HP_buyingstore_getuid_pre;
+struct HPMHookPoint *HP_buyingstore_getuid_post;
+struct HPMHookPoint *HP_chat_create_pc_chat_pre;
+struct HPMHookPoint *HP_chat_create_pc_chat_post;
+struct HPMHookPoint *HP_chat_join_pre;
+struct HPMHookPoint *HP_chat_join_post;
+struct HPMHookPoint *HP_chat_leave_pre;
+struct HPMHookPoint *HP_chat_leave_post;
+struct HPMHookPoint *HP_chat_change_owner_pre;
+struct HPMHookPoint *HP_chat_change_owner_post;
+struct HPMHookPoint *HP_chat_change_status_pre;
+struct HPMHookPoint *HP_chat_change_status_post;
+struct HPMHookPoint *HP_chat_kick_pre;
+struct HPMHookPoint *HP_chat_kick_post;
+struct HPMHookPoint *HP_chat_create_npc_chat_pre;
+struct HPMHookPoint *HP_chat_create_npc_chat_post;
+struct HPMHookPoint *HP_chat_delete_npc_chat_pre;
+struct HPMHookPoint *HP_chat_delete_npc_chat_post;
+struct HPMHookPoint *HP_chat_enable_event_pre;
+struct HPMHookPoint *HP_chat_enable_event_post;
+struct HPMHookPoint *HP_chat_disable_event_pre;
+struct HPMHookPoint *HP_chat_disable_event_post;
+struct HPMHookPoint *HP_chat_npc_kick_all_pre;
+struct HPMHookPoint *HP_chat_npc_kick_all_post;
+struct HPMHookPoint *HP_chat_trigger_event_pre;
+struct HPMHookPoint *HP_chat_trigger_event_post;
+struct HPMHookPoint *HP_chat_create_pre;
+struct HPMHookPoint *HP_chat_create_post;
+struct HPMHookPoint *HP_chrif_final_pre;
+struct HPMHookPoint *HP_chrif_final_post;
+struct HPMHookPoint *HP_chrif_init_pre;
+struct HPMHookPoint *HP_chrif_init_post;
+struct HPMHookPoint *HP_chrif_setuserid_pre;
+struct HPMHookPoint *HP_chrif_setuserid_post;
+struct HPMHookPoint *HP_chrif_setpasswd_pre;
+struct HPMHookPoint *HP_chrif_setpasswd_post;
+struct HPMHookPoint *HP_chrif_checkdefaultlogin_pre;
+struct HPMHookPoint *HP_chrif_checkdefaultlogin_post;
+struct HPMHookPoint *HP_chrif_setip_pre;
+struct HPMHookPoint *HP_chrif_setip_post;
+struct HPMHookPoint *HP_chrif_setport_pre;
+struct HPMHookPoint *HP_chrif_setport_post;
+struct HPMHookPoint *HP_chrif_isconnected_pre;
+struct HPMHookPoint *HP_chrif_isconnected_post;
+struct HPMHookPoint *HP_chrif_check_shutdown_pre;
+struct HPMHookPoint *HP_chrif_check_shutdown_post;
+struct HPMHookPoint *HP_chrif_search_pre;
+struct HPMHookPoint *HP_chrif_search_post;
+struct HPMHookPoint *HP_chrif_auth_check_pre;
+struct HPMHookPoint *HP_chrif_auth_check_post;
+struct HPMHookPoint *HP_chrif_auth_delete_pre;
+struct HPMHookPoint *HP_chrif_auth_delete_post;
+struct HPMHookPoint *HP_chrif_auth_finished_pre;
+struct HPMHookPoint *HP_chrif_auth_finished_post;
+struct HPMHookPoint *HP_chrif_authreq_pre;
+struct HPMHookPoint *HP_chrif_authreq_post;
+struct HPMHookPoint *HP_chrif_authok_pre;
+struct HPMHookPoint *HP_chrif_authok_post;
+struct HPMHookPoint *HP_chrif_scdata_request_pre;
+struct HPMHookPoint *HP_chrif_scdata_request_post;
+struct HPMHookPoint *HP_chrif_save_pre;
+struct HPMHookPoint *HP_chrif_save_post;
+struct HPMHookPoint *HP_chrif_charselectreq_pre;
+struct HPMHookPoint *HP_chrif_charselectreq_post;
+struct HPMHookPoint *HP_chrif_changemapserver_pre;
+struct HPMHookPoint *HP_chrif_changemapserver_post;
+struct HPMHookPoint *HP_chrif_searchcharid_pre;
+struct HPMHookPoint *HP_chrif_searchcharid_post;
+struct HPMHookPoint *HP_chrif_changeemail_pre;
+struct HPMHookPoint *HP_chrif_changeemail_post;
+struct HPMHookPoint *HP_chrif_char_ask_name_pre;
+struct HPMHookPoint *HP_chrif_char_ask_name_post;
+struct HPMHookPoint *HP_chrif_updatefamelist_pre;
+struct HPMHookPoint *HP_chrif_updatefamelist_post;
+struct HPMHookPoint *HP_chrif_buildfamelist_pre;
+struct HPMHookPoint *HP_chrif_buildfamelist_post;
+struct HPMHookPoint *HP_chrif_save_scdata_pre;
+struct HPMHookPoint *HP_chrif_save_scdata_post;
+struct HPMHookPoint *HP_chrif_ragsrvinfo_pre;
+struct HPMHookPoint *HP_chrif_ragsrvinfo_post;
+struct HPMHookPoint *HP_chrif_char_offline_pre;
+struct HPMHookPoint *HP_chrif_char_offline_post;
+struct HPMHookPoint *HP_chrif_char_offline_nsd_pre;
+struct HPMHookPoint *HP_chrif_char_offline_nsd_post;
+struct HPMHookPoint *HP_chrif_char_reset_offline_pre;
+struct HPMHookPoint *HP_chrif_char_reset_offline_post;
+struct HPMHookPoint *HP_chrif_send_users_tochar_pre;
+struct HPMHookPoint *HP_chrif_send_users_tochar_post;
+struct HPMHookPoint *HP_chrif_char_online_pre;
+struct HPMHookPoint *HP_chrif_char_online_post;
+struct HPMHookPoint *HP_chrif_changesex_pre;
+struct HPMHookPoint *HP_chrif_changesex_post;
+struct HPMHookPoint *HP_chrif_divorce_pre;
+struct HPMHookPoint *HP_chrif_divorce_post;
+struct HPMHookPoint *HP_chrif_removefriend_pre;
+struct HPMHookPoint *HP_chrif_removefriend_post;
+struct HPMHookPoint *HP_chrif_send_report_pre;
+struct HPMHookPoint *HP_chrif_send_report_post;
+struct HPMHookPoint *HP_chrif_flush_fifo_pre;
+struct HPMHookPoint *HP_chrif_flush_fifo_post;
+struct HPMHookPoint *HP_chrif_skillid2idx_pre;
+struct HPMHookPoint *HP_chrif_skillid2idx_post;
+struct HPMHookPoint *HP_chrif_sd_to_auth_pre;
+struct HPMHookPoint *HP_chrif_sd_to_auth_post;
+struct HPMHookPoint *HP_chrif_check_connect_char_server_pre;
+struct HPMHookPoint *HP_chrif_check_connect_char_server_post;
+struct HPMHookPoint *HP_chrif_auth_logout_pre;
+struct HPMHookPoint *HP_chrif_auth_logout_post;
+struct HPMHookPoint *HP_chrif_save_ack_pre;
+struct HPMHookPoint *HP_chrif_save_ack_post;
+struct HPMHookPoint *HP_chrif_reconnect_pre;
+struct HPMHookPoint *HP_chrif_reconnect_post;
+struct HPMHookPoint *HP_chrif_auth_db_cleanup_sub_pre;
+struct HPMHookPoint *HP_chrif_auth_db_cleanup_sub_post;
+struct HPMHookPoint *HP_chrif_char_ask_name_answer_pre;
+struct HPMHookPoint *HP_chrif_char_ask_name_answer_post;
+struct HPMHookPoint *HP_chrif_auth_db_final_pre;
+struct HPMHookPoint *HP_chrif_auth_db_final_post;
+struct HPMHookPoint *HP_chrif_send_usercount_tochar_pre;
+struct HPMHookPoint *HP_chrif_send_usercount_tochar_post;
+struct HPMHookPoint *HP_chrif_auth_db_cleanup_pre;
+struct HPMHookPoint *HP_chrif_auth_db_cleanup_post;
+struct HPMHookPoint *HP_chrif_connect_pre;
+struct HPMHookPoint *HP_chrif_connect_post;
+struct HPMHookPoint *HP_chrif_connectack_pre;
+struct HPMHookPoint *HP_chrif_connectack_post;
+struct HPMHookPoint *HP_chrif_sendmap_pre;
+struct HPMHookPoint *HP_chrif_sendmap_post;
+struct HPMHookPoint *HP_chrif_sendmapack_pre;
+struct HPMHookPoint *HP_chrif_sendmapack_post;
+struct HPMHookPoint *HP_chrif_recvmap_pre;
+struct HPMHookPoint *HP_chrif_recvmap_post;
+struct HPMHookPoint *HP_chrif_changemapserverack_pre;
+struct HPMHookPoint *HP_chrif_changemapserverack_post;
+struct HPMHookPoint *HP_chrif_changedsex_pre;
+struct HPMHookPoint *HP_chrif_changedsex_post;
+struct HPMHookPoint *HP_chrif_divorceack_pre;
+struct HPMHookPoint *HP_chrif_divorceack_post;
+struct HPMHookPoint *HP_chrif_accountban_pre;
+struct HPMHookPoint *HP_chrif_accountban_post;
+struct HPMHookPoint *HP_chrif_recvfamelist_pre;
+struct HPMHookPoint *HP_chrif_recvfamelist_post;
+struct HPMHookPoint *HP_chrif_load_scdata_pre;
+struct HPMHookPoint *HP_chrif_load_scdata_post;
+struct HPMHookPoint *HP_chrif_update_ip_pre;
+struct HPMHookPoint *HP_chrif_update_ip_post;
+struct HPMHookPoint *HP_chrif_disconnectplayer_pre;
+struct HPMHookPoint *HP_chrif_disconnectplayer_post;
+struct HPMHookPoint *HP_chrif_removemap_pre;
+struct HPMHookPoint *HP_chrif_removemap_post;
+struct HPMHookPoint *HP_chrif_updatefamelist_ack_pre;
+struct HPMHookPoint *HP_chrif_updatefamelist_ack_post;
+struct HPMHookPoint *HP_chrif_keepalive_pre;
+struct HPMHookPoint *HP_chrif_keepalive_post;
+struct HPMHookPoint *HP_chrif_keepalive_ack_pre;
+struct HPMHookPoint *HP_chrif_keepalive_ack_post;
+struct HPMHookPoint *HP_chrif_deadopt_pre;
+struct HPMHookPoint *HP_chrif_deadopt_post;
+struct HPMHookPoint *HP_chrif_authfail_pre;
+struct HPMHookPoint *HP_chrif_authfail_post;
+struct HPMHookPoint *HP_chrif_on_ready_pre;
+struct HPMHookPoint *HP_chrif_on_ready_post;
+struct HPMHookPoint *HP_chrif_on_disconnect_pre;
+struct HPMHookPoint *HP_chrif_on_disconnect_post;
+struct HPMHookPoint *HP_chrif_parse_pre;
+struct HPMHookPoint *HP_chrif_parse_post;
+struct HPMHookPoint *HP_clif_init_pre;
+struct HPMHookPoint *HP_clif_init_post;
+struct HPMHookPoint *HP_clif_final_pre;
+struct HPMHookPoint *HP_clif_final_post;
+struct HPMHookPoint *HP_clif_setip_pre;
+struct HPMHookPoint *HP_clif_setip_post;
+struct HPMHookPoint *HP_clif_setbindip_pre;
+struct HPMHookPoint *HP_clif_setbindip_post;
+struct HPMHookPoint *HP_clif_setport_pre;
+struct HPMHookPoint *HP_clif_setport_post;
+struct HPMHookPoint *HP_clif_refresh_ip_pre;
+struct HPMHookPoint *HP_clif_refresh_ip_post;
+struct HPMHookPoint *HP_clif_send_pre;
+struct HPMHookPoint *HP_clif_send_post;
+struct HPMHookPoint *HP_clif_send_sub_pre;
+struct HPMHookPoint *HP_clif_send_sub_post;
+struct HPMHookPoint *HP_clif_parse_pre;
+struct HPMHookPoint *HP_clif_parse_post;
+struct HPMHookPoint *HP_clif_parse_cmd_pre;
+struct HPMHookPoint *HP_clif_parse_cmd_post;
+struct HPMHookPoint *HP_clif_decrypt_cmd_pre;
+struct HPMHookPoint *HP_clif_decrypt_cmd_post;
+struct HPMHookPoint *HP_clif_authok_pre;
+struct HPMHookPoint *HP_clif_authok_post;
+struct HPMHookPoint *HP_clif_authrefuse_pre;
+struct HPMHookPoint *HP_clif_authrefuse_post;
+struct HPMHookPoint *HP_clif_authfail_fd_pre;
+struct HPMHookPoint *HP_clif_authfail_fd_post;
+struct HPMHookPoint *HP_clif_charselectok_pre;
+struct HPMHookPoint *HP_clif_charselectok_post;
+struct HPMHookPoint *HP_clif_dropflooritem_pre;
+struct HPMHookPoint *HP_clif_dropflooritem_post;
+struct HPMHookPoint *HP_clif_clearflooritem_pre;
+struct HPMHookPoint *HP_clif_clearflooritem_post;
+struct HPMHookPoint *HP_clif_additem_pre;
+struct HPMHookPoint *HP_clif_additem_post;
+struct HPMHookPoint *HP_clif_dropitem_pre;
+struct HPMHookPoint *HP_clif_dropitem_post;
+struct HPMHookPoint *HP_clif_delitem_pre;
+struct HPMHookPoint *HP_clif_delitem_post;
+struct HPMHookPoint *HP_clif_takeitem_pre;
+struct HPMHookPoint *HP_clif_takeitem_post;
+struct HPMHookPoint *HP_clif_arrowequip_pre;
+struct HPMHookPoint *HP_clif_arrowequip_post;
+struct HPMHookPoint *HP_clif_arrow_fail_pre;
+struct HPMHookPoint *HP_clif_arrow_fail_post;
+struct HPMHookPoint *HP_clif_use_card_pre;
+struct HPMHookPoint *HP_clif_use_card_post;
+struct HPMHookPoint *HP_clif_cart_additem_pre;
+struct HPMHookPoint *HP_clif_cart_additem_post;
+struct HPMHookPoint *HP_clif_cart_delitem_pre;
+struct HPMHookPoint *HP_clif_cart_delitem_post;
+struct HPMHookPoint *HP_clif_equipitemack_pre;
+struct HPMHookPoint *HP_clif_equipitemack_post;
+struct HPMHookPoint *HP_clif_unequipitemack_pre;
+struct HPMHookPoint *HP_clif_unequipitemack_post;
+struct HPMHookPoint *HP_clif_useitemack_pre;
+struct HPMHookPoint *HP_clif_useitemack_post;
+struct HPMHookPoint *HP_clif_addcards_pre;
+struct HPMHookPoint *HP_clif_addcards_post;
+struct HPMHookPoint *HP_clif_addcards2_pre;
+struct HPMHookPoint *HP_clif_addcards2_post;
+struct HPMHookPoint *HP_clif_item_sub_pre;
+struct HPMHookPoint *HP_clif_item_sub_post;
+struct HPMHookPoint *HP_clif_getareachar_item_pre;
+struct HPMHookPoint *HP_clif_getareachar_item_post;
+struct HPMHookPoint *HP_clif_cart_additem_ack_pre;
+struct HPMHookPoint *HP_clif_cart_additem_ack_post;
+struct HPMHookPoint *HP_clif_cashshop_load_pre;
+struct HPMHookPoint *HP_clif_cashshop_load_post;
+struct HPMHookPoint *HP_clif_package_announce_pre;
+struct HPMHookPoint *HP_clif_package_announce_post;
+struct HPMHookPoint *HP_clif_clearunit_single_pre;
+struct HPMHookPoint *HP_clif_clearunit_single_post;
+struct HPMHookPoint *HP_clif_clearunit_area_pre;
+struct HPMHookPoint *HP_clif_clearunit_area_post;
+struct HPMHookPoint *HP_clif_clearunit_delayed_pre;
+struct HPMHookPoint *HP_clif_clearunit_delayed_post;
+struct HPMHookPoint *HP_clif_walkok_pre;
+struct HPMHookPoint *HP_clif_walkok_post;
+struct HPMHookPoint *HP_clif_move_pre;
+struct HPMHookPoint *HP_clif_move_post;
+struct HPMHookPoint *HP_clif_move2_pre;
+struct HPMHookPoint *HP_clif_move2_post;
+struct HPMHookPoint *HP_clif_blown_pre;
+struct HPMHookPoint *HP_clif_blown_post;
+struct HPMHookPoint *HP_clif_slide_pre;
+struct HPMHookPoint *HP_clif_slide_post;
+struct HPMHookPoint *HP_clif_fixpos_pre;
+struct HPMHookPoint *HP_clif_fixpos_post;
+struct HPMHookPoint *HP_clif_changelook_pre;
+struct HPMHookPoint *HP_clif_changelook_post;
+struct HPMHookPoint *HP_clif_changetraplook_pre;
+struct HPMHookPoint *HP_clif_changetraplook_post;
+struct HPMHookPoint *HP_clif_refreshlook_pre;
+struct HPMHookPoint *HP_clif_refreshlook_post;
+struct HPMHookPoint *HP_clif_class_change_pre;
+struct HPMHookPoint *HP_clif_class_change_post;
+struct HPMHookPoint *HP_clif_skill_setunit_pre;
+struct HPMHookPoint *HP_clif_skill_setunit_post;
+struct HPMHookPoint *HP_clif_skill_delunit_pre;
+struct HPMHookPoint *HP_clif_skill_delunit_post;
+struct HPMHookPoint *HP_clif_skillunit_update_pre;
+struct HPMHookPoint *HP_clif_skillunit_update_post;
+struct HPMHookPoint *HP_clif_clearunit_delayed_sub_pre;
+struct HPMHookPoint *HP_clif_clearunit_delayed_sub_post;
+struct HPMHookPoint *HP_clif_set_unit_idle_pre;
+struct HPMHookPoint *HP_clif_set_unit_idle_post;
+struct HPMHookPoint *HP_clif_spawn_unit_pre;
+struct HPMHookPoint *HP_clif_spawn_unit_post;
+struct HPMHookPoint *HP_clif_set_unit_walking_pre;
+struct HPMHookPoint *HP_clif_set_unit_walking_post;
+struct HPMHookPoint *HP_clif_calc_walkdelay_pre;
+struct HPMHookPoint *HP_clif_calc_walkdelay_post;
+struct HPMHookPoint *HP_clif_getareachar_skillunit_pre;
+struct HPMHookPoint *HP_clif_getareachar_skillunit_post;
+struct HPMHookPoint *HP_clif_getareachar_unit_pre;
+struct HPMHookPoint *HP_clif_getareachar_unit_post;
+struct HPMHookPoint *HP_clif_clearchar_skillunit_pre;
+struct HPMHookPoint *HP_clif_clearchar_skillunit_post;
+struct HPMHookPoint *HP_clif_getareachar_pre;
+struct HPMHookPoint *HP_clif_getareachar_post;
+struct HPMHookPoint *HP_clif_spawn_pre;
+struct HPMHookPoint *HP_clif_spawn_post;
+struct HPMHookPoint *HP_clif_changemap_pre;
+struct HPMHookPoint *HP_clif_changemap_post;
+struct HPMHookPoint *HP_clif_changemapcell_pre;
+struct HPMHookPoint *HP_clif_changemapcell_post;
+struct HPMHookPoint *HP_clif_map_property_pre;
+struct HPMHookPoint *HP_clif_map_property_post;
+struct HPMHookPoint *HP_clif_pvpset_pre;
+struct HPMHookPoint *HP_clif_pvpset_post;
+struct HPMHookPoint *HP_clif_map_property_mapall_pre;
+struct HPMHookPoint *HP_clif_map_property_mapall_post;
+struct HPMHookPoint *HP_clif_bossmapinfo_pre;
+struct HPMHookPoint *HP_clif_bossmapinfo_post;
+struct HPMHookPoint *HP_clif_map_type_pre;
+struct HPMHookPoint *HP_clif_map_type_post;
+struct HPMHookPoint *HP_clif_maptypeproperty2_pre;
+struct HPMHookPoint *HP_clif_maptypeproperty2_post;
+struct HPMHookPoint *HP_clif_changemapserver_pre;
+struct HPMHookPoint *HP_clif_changemapserver_post;
+struct HPMHookPoint *HP_clif_npcbuysell_pre;
+struct HPMHookPoint *HP_clif_npcbuysell_post;
+struct HPMHookPoint *HP_clif_buylist_pre;
+struct HPMHookPoint *HP_clif_buylist_post;
+struct HPMHookPoint *HP_clif_selllist_pre;
+struct HPMHookPoint *HP_clif_selllist_post;
+struct HPMHookPoint *HP_clif_cashshop_show_pre;
+struct HPMHookPoint *HP_clif_cashshop_show_post;
+struct HPMHookPoint *HP_clif_npc_buy_result_pre;
+struct HPMHookPoint *HP_clif_npc_buy_result_post;
+struct HPMHookPoint *HP_clif_npc_sell_result_pre;
+struct HPMHookPoint *HP_clif_npc_sell_result_post;
+struct HPMHookPoint *HP_clif_cashshop_ack_pre;
+struct HPMHookPoint *HP_clif_cashshop_ack_post;
+struct HPMHookPoint *HP_clif_scriptmes_pre;
+struct HPMHookPoint *HP_clif_scriptmes_post;
+struct HPMHookPoint *HP_clif_scriptnext_pre;
+struct HPMHookPoint *HP_clif_scriptnext_post;
+struct HPMHookPoint *HP_clif_scriptclose_pre;
+struct HPMHookPoint *HP_clif_scriptclose_post;
+struct HPMHookPoint *HP_clif_scriptmenu_pre;
+struct HPMHookPoint *HP_clif_scriptmenu_post;
+struct HPMHookPoint *HP_clif_scriptinput_pre;
+struct HPMHookPoint *HP_clif_scriptinput_post;
+struct HPMHookPoint *HP_clif_scriptinputstr_pre;
+struct HPMHookPoint *HP_clif_scriptinputstr_post;
+struct HPMHookPoint *HP_clif_cutin_pre;
+struct HPMHookPoint *HP_clif_cutin_post;
+struct HPMHookPoint *HP_clif_sendfakenpc_pre;
+struct HPMHookPoint *HP_clif_sendfakenpc_post;
+struct HPMHookPoint *HP_clif_scriptclear_pre;
+struct HPMHookPoint *HP_clif_scriptclear_post;
+struct HPMHookPoint *HP_clif_viewpoint_pre;
+struct HPMHookPoint *HP_clif_viewpoint_post;
+struct HPMHookPoint *HP_clif_damage_pre;
+struct HPMHookPoint *HP_clif_damage_post;
+struct HPMHookPoint *HP_clif_sitting_pre;
+struct HPMHookPoint *HP_clif_sitting_post;
+struct HPMHookPoint *HP_clif_standing_pre;
+struct HPMHookPoint *HP_clif_standing_post;
+struct HPMHookPoint *HP_clif_arrow_create_list_pre;
+struct HPMHookPoint *HP_clif_arrow_create_list_post;
+struct HPMHookPoint *HP_clif_refresh_pre;
+struct HPMHookPoint *HP_clif_refresh_post;
+struct HPMHookPoint *HP_clif_fame_blacksmith_pre;
+struct HPMHookPoint *HP_clif_fame_blacksmith_post;
+struct HPMHookPoint *HP_clif_fame_alchemist_pre;
+struct HPMHookPoint *HP_clif_fame_alchemist_post;
+struct HPMHookPoint *HP_clif_fame_taekwon_pre;
+struct HPMHookPoint *HP_clif_fame_taekwon_post;
+struct HPMHookPoint *HP_clif_ranklist_pre;
+struct HPMHookPoint *HP_clif_ranklist_post;
+struct HPMHookPoint *HP_clif_update_rankingpoint_pre;
+struct HPMHookPoint *HP_clif_update_rankingpoint_post;
+struct HPMHookPoint *HP_clif_pRanklist_pre;
+struct HPMHookPoint *HP_clif_pRanklist_post;
+struct HPMHookPoint *HP_clif_hotkeys_pre;
+struct HPMHookPoint *HP_clif_hotkeys_post;
+struct HPMHookPoint *HP_clif_insight_pre;
+struct HPMHookPoint *HP_clif_insight_post;
+struct HPMHookPoint *HP_clif_outsight_pre;
+struct HPMHookPoint *HP_clif_outsight_post;
+struct HPMHookPoint *HP_clif_skillcastcancel_pre;
+struct HPMHookPoint *HP_clif_skillcastcancel_post;
+struct HPMHookPoint *HP_clif_skill_fail_pre;
+struct HPMHookPoint *HP_clif_skill_fail_post;
+struct HPMHookPoint *HP_clif_skill_cooldown_pre;
+struct HPMHookPoint *HP_clif_skill_cooldown_post;
+struct HPMHookPoint *HP_clif_skill_memomessage_pre;
+struct HPMHookPoint *HP_clif_skill_memomessage_post;
+struct HPMHookPoint *HP_clif_skill_mapinfomessage_pre;
+struct HPMHookPoint *HP_clif_skill_mapinfomessage_post;
+struct HPMHookPoint *HP_clif_skill_produce_mix_list_pre;
+struct HPMHookPoint *HP_clif_skill_produce_mix_list_post;
+struct HPMHookPoint *HP_clif_cooking_list_pre;
+struct HPMHookPoint *HP_clif_cooking_list_post;
+struct HPMHookPoint *HP_clif_autospell_pre;
+struct HPMHookPoint *HP_clif_autospell_post;
+struct HPMHookPoint *HP_clif_combo_delay_pre;
+struct HPMHookPoint *HP_clif_combo_delay_post;
+struct HPMHookPoint *HP_clif_status_change_pre;
+struct HPMHookPoint *HP_clif_status_change_post;
+struct HPMHookPoint *HP_clif_insert_card_pre;
+struct HPMHookPoint *HP_clif_insert_card_post;
+struct HPMHookPoint *HP_clif_inventorylist_pre;
+struct HPMHookPoint *HP_clif_inventorylist_post;
+struct HPMHookPoint *HP_clif_equiplist_pre;
+struct HPMHookPoint *HP_clif_equiplist_post;
+struct HPMHookPoint *HP_clif_cartlist_pre;
+struct HPMHookPoint *HP_clif_cartlist_post;
+struct HPMHookPoint *HP_clif_favorite_item_pre;
+struct HPMHookPoint *HP_clif_favorite_item_post;
+struct HPMHookPoint *HP_clif_clearcart_pre;
+struct HPMHookPoint *HP_clif_clearcart_post;
+struct HPMHookPoint *HP_clif_item_identify_list_pre;
+struct HPMHookPoint *HP_clif_item_identify_list_post;
+struct HPMHookPoint *HP_clif_item_identified_pre;
+struct HPMHookPoint *HP_clif_item_identified_post;
+struct HPMHookPoint *HP_clif_item_repair_list_pre;
+struct HPMHookPoint *HP_clif_item_repair_list_post;
+struct HPMHookPoint *HP_clif_item_repaireffect_pre;
+struct HPMHookPoint *HP_clif_item_repaireffect_post;
+struct HPMHookPoint *HP_clif_item_damaged_pre;
+struct HPMHookPoint *HP_clif_item_damaged_post;
+struct HPMHookPoint *HP_clif_item_refine_list_pre;
+struct HPMHookPoint *HP_clif_item_refine_list_post;
+struct HPMHookPoint *HP_clif_item_skill_pre;
+struct HPMHookPoint *HP_clif_item_skill_post;
+struct HPMHookPoint *HP_clif_mvp_item_pre;
+struct HPMHookPoint *HP_clif_mvp_item_post;
+struct HPMHookPoint *HP_clif_mvp_exp_pre;
+struct HPMHookPoint *HP_clif_mvp_exp_post;
+struct HPMHookPoint *HP_clif_mvp_noitem_pre;
+struct HPMHookPoint *HP_clif_mvp_noitem_post;
+struct HPMHookPoint *HP_clif_changed_dir_pre;
+struct HPMHookPoint *HP_clif_changed_dir_post;
+struct HPMHookPoint *HP_clif_charnameack_pre;
+struct HPMHookPoint *HP_clif_charnameack_post;
+struct HPMHookPoint *HP_clif_monster_hp_bar_pre;
+struct HPMHookPoint *HP_clif_monster_hp_bar_post;
+struct HPMHookPoint *HP_clif_hpmeter_pre;
+struct HPMHookPoint *HP_clif_hpmeter_post;
+struct HPMHookPoint *HP_clif_hpmeter_single_pre;
+struct HPMHookPoint *HP_clif_hpmeter_single_post;
+struct HPMHookPoint *HP_clif_hpmeter_sub_pre;
+struct HPMHookPoint *HP_clif_hpmeter_sub_post;
+struct HPMHookPoint *HP_clif_upgrademessage_pre;
+struct HPMHookPoint *HP_clif_upgrademessage_post;
+struct HPMHookPoint *HP_clif_get_weapon_view_pre;
+struct HPMHookPoint *HP_clif_get_weapon_view_post;
+struct HPMHookPoint *HP_clif_gospel_info_pre;
+struct HPMHookPoint *HP_clif_gospel_info_post;
+struct HPMHookPoint *HP_clif_feel_req_pre;
+struct HPMHookPoint *HP_clif_feel_req_post;
+struct HPMHookPoint *HP_clif_starskill_pre;
+struct HPMHookPoint *HP_clif_starskill_post;
+struct HPMHookPoint *HP_clif_feel_info_pre;
+struct HPMHookPoint *HP_clif_feel_info_post;
+struct HPMHookPoint *HP_clif_hate_info_pre;
+struct HPMHookPoint *HP_clif_hate_info_post;
+struct HPMHookPoint *HP_clif_mission_info_pre;
+struct HPMHookPoint *HP_clif_mission_info_post;
+struct HPMHookPoint *HP_clif_feel_hate_reset_pre;
+struct HPMHookPoint *HP_clif_feel_hate_reset_post;
+struct HPMHookPoint *HP_clif_partytickack_pre;
+struct HPMHookPoint *HP_clif_partytickack_post;
+struct HPMHookPoint *HP_clif_equiptickack_pre;
+struct HPMHookPoint *HP_clif_equiptickack_post;
+struct HPMHookPoint *HP_clif_viewequip_ack_pre;
+struct HPMHookPoint *HP_clif_viewequip_ack_post;
+struct HPMHookPoint *HP_clif_viewequip_fail_pre;
+struct HPMHookPoint *HP_clif_viewequip_fail_post;
+struct HPMHookPoint *HP_clif_equpcheckbox_pre;
+struct HPMHookPoint *HP_clif_equpcheckbox_post;
+struct HPMHookPoint *HP_clif_displayexp_pre;
+struct HPMHookPoint *HP_clif_displayexp_post;
+struct HPMHookPoint *HP_clif_font_pre;
+struct HPMHookPoint *HP_clif_font_post;
+struct HPMHookPoint *HP_clif_progressbar_pre;
+struct HPMHookPoint *HP_clif_progressbar_post;
+struct HPMHookPoint *HP_clif_progressbar_abort_pre;
+struct HPMHookPoint *HP_clif_progressbar_abort_post;
+struct HPMHookPoint *HP_clif_showdigit_pre;
+struct HPMHookPoint *HP_clif_showdigit_post;
+struct HPMHookPoint *HP_clif_elementalconverter_list_pre;
+struct HPMHookPoint *HP_clif_elementalconverter_list_post;
+struct HPMHookPoint *HP_clif_spellbook_list_pre;
+struct HPMHookPoint *HP_clif_spellbook_list_post;
+struct HPMHookPoint *HP_clif_magicdecoy_list_pre;
+struct HPMHookPoint *HP_clif_magicdecoy_list_post;
+struct HPMHookPoint *HP_clif_poison_list_pre;
+struct HPMHookPoint *HP_clif_poison_list_post;
+struct HPMHookPoint *HP_clif_autoshadowspell_list_pre;
+struct HPMHookPoint *HP_clif_autoshadowspell_list_post;
+struct HPMHookPoint *HP_clif_skill_itemlistwindow_pre;
+struct HPMHookPoint *HP_clif_skill_itemlistwindow_post;
+struct HPMHookPoint *HP_clif_sc_load_pre;
+struct HPMHookPoint *HP_clif_sc_load_post;
+struct HPMHookPoint *HP_clif_sc_end_pre;
+struct HPMHookPoint *HP_clif_sc_end_post;
+struct HPMHookPoint *HP_clif_initialstatus_pre;
+struct HPMHookPoint *HP_clif_initialstatus_post;
+struct HPMHookPoint *HP_clif_cooldown_list_pre;
+struct HPMHookPoint *HP_clif_cooldown_list_post;
+struct HPMHookPoint *HP_clif_updatestatus_pre;
+struct HPMHookPoint *HP_clif_updatestatus_post;
+struct HPMHookPoint *HP_clif_changestatus_pre;
+struct HPMHookPoint *HP_clif_changestatus_post;
+struct HPMHookPoint *HP_clif_statusupack_pre;
+struct HPMHookPoint *HP_clif_statusupack_post;
+struct HPMHookPoint *HP_clif_movetoattack_pre;
+struct HPMHookPoint *HP_clif_movetoattack_post;
+struct HPMHookPoint *HP_clif_solved_charname_pre;
+struct HPMHookPoint *HP_clif_solved_charname_post;
+struct HPMHookPoint *HP_clif_charnameupdate_pre;
+struct HPMHookPoint *HP_clif_charnameupdate_post;
+struct HPMHookPoint *HP_clif_delayquit_pre;
+struct HPMHookPoint *HP_clif_delayquit_post;
+struct HPMHookPoint *HP_clif_getareachar_pc_pre;
+struct HPMHookPoint *HP_clif_getareachar_pc_post;
+struct HPMHookPoint *HP_clif_disconnect_ack_pre;
+struct HPMHookPoint *HP_clif_disconnect_ack_post;
+struct HPMHookPoint *HP_clif_PVPInfo_pre;
+struct HPMHookPoint *HP_clif_PVPInfo_post;
+struct HPMHookPoint *HP_clif_blacksmith_pre;
+struct HPMHookPoint *HP_clif_blacksmith_post;
+struct HPMHookPoint *HP_clif_alchemist_pre;
+struct HPMHookPoint *HP_clif_alchemist_post;
+struct HPMHookPoint *HP_clif_taekwon_pre;
+struct HPMHookPoint *HP_clif_taekwon_post;
+struct HPMHookPoint *HP_clif_ranking_pk_pre;
+struct HPMHookPoint *HP_clif_ranking_pk_post;
+struct HPMHookPoint *HP_clif_quitsave_pre;
+struct HPMHookPoint *HP_clif_quitsave_post;
+struct HPMHookPoint *HP_clif_misceffect_pre;
+struct HPMHookPoint *HP_clif_misceffect_post;
+struct HPMHookPoint *HP_clif_changeoption_pre;
+struct HPMHookPoint *HP_clif_changeoption_post;
+struct HPMHookPoint *HP_clif_changeoption2_pre;
+struct HPMHookPoint *HP_clif_changeoption2_post;
+struct HPMHookPoint *HP_clif_emotion_pre;
+struct HPMHookPoint *HP_clif_emotion_post;
+struct HPMHookPoint *HP_clif_talkiebox_pre;
+struct HPMHookPoint *HP_clif_talkiebox_post;
+struct HPMHookPoint *HP_clif_wedding_effect_pre;
+struct HPMHookPoint *HP_clif_wedding_effect_post;
+struct HPMHookPoint *HP_clif_divorced_pre;
+struct HPMHookPoint *HP_clif_divorced_post;
+struct HPMHookPoint *HP_clif_callpartner_pre;
+struct HPMHookPoint *HP_clif_callpartner_post;
+struct HPMHookPoint *HP_clif_skill_damage_pre;
+struct HPMHookPoint *HP_clif_skill_damage_post;
+struct HPMHookPoint *HP_clif_skill_nodamage_pre;
+struct HPMHookPoint *HP_clif_skill_nodamage_post;
+struct HPMHookPoint *HP_clif_skill_poseffect_pre;
+struct HPMHookPoint *HP_clif_skill_poseffect_post;
+struct HPMHookPoint *HP_clif_skill_estimation_pre;
+struct HPMHookPoint *HP_clif_skill_estimation_post;
+struct HPMHookPoint *HP_clif_skill_warppoint_pre;
+struct HPMHookPoint *HP_clif_skill_warppoint_post;
+struct HPMHookPoint *HP_clif_skillcasting_pre;
+struct HPMHookPoint *HP_clif_skillcasting_post;
+struct HPMHookPoint *HP_clif_produce_effect_pre;
+struct HPMHookPoint *HP_clif_produce_effect_post;
+struct HPMHookPoint *HP_clif_devotion_pre;
+struct HPMHookPoint *HP_clif_devotion_post;
+struct HPMHookPoint *HP_clif_spiritball_pre;
+struct HPMHookPoint *HP_clif_spiritball_post;
+struct HPMHookPoint *HP_clif_spiritball_single_pre;
+struct HPMHookPoint *HP_clif_spiritball_single_post;
+struct HPMHookPoint *HP_clif_bladestop_pre;
+struct HPMHookPoint *HP_clif_bladestop_post;
+struct HPMHookPoint *HP_clif_mvp_effect_pre;
+struct HPMHookPoint *HP_clif_mvp_effect_post;
+struct HPMHookPoint *HP_clif_heal_pre;
+struct HPMHookPoint *HP_clif_heal_post;
+struct HPMHookPoint *HP_clif_resurrection_pre;
+struct HPMHookPoint *HP_clif_resurrection_post;
+struct HPMHookPoint *HP_clif_refine_pre;
+struct HPMHookPoint *HP_clif_refine_post;
+struct HPMHookPoint *HP_clif_weather_pre;
+struct HPMHookPoint *HP_clif_weather_post;
+struct HPMHookPoint *HP_clif_specialeffect_pre;
+struct HPMHookPoint *HP_clif_specialeffect_post;
+struct HPMHookPoint *HP_clif_specialeffect_single_pre;
+struct HPMHookPoint *HP_clif_specialeffect_single_post;
+struct HPMHookPoint *HP_clif_specialeffect_value_pre;
+struct HPMHookPoint *HP_clif_specialeffect_value_post;
+struct HPMHookPoint *HP_clif_millenniumshield_pre;
+struct HPMHookPoint *HP_clif_millenniumshield_post;
+struct HPMHookPoint *HP_clif_charm_pre;
+struct HPMHookPoint *HP_clif_charm_post;
+struct HPMHookPoint *HP_clif_charm_single_pre;
+struct HPMHookPoint *HP_clif_charm_single_post;
+struct HPMHookPoint *HP_clif_snap_pre;
+struct HPMHookPoint *HP_clif_snap_post;
+struct HPMHookPoint *HP_clif_weather_check_pre;
+struct HPMHookPoint *HP_clif_weather_check_post;
+struct HPMHookPoint *HP_clif_playBGM_pre;
+struct HPMHookPoint *HP_clif_playBGM_post;
+struct HPMHookPoint *HP_clif_soundeffect_pre;
+struct HPMHookPoint *HP_clif_soundeffect_post;
+struct HPMHookPoint *HP_clif_soundeffectall_pre;
+struct HPMHookPoint *HP_clif_soundeffectall_post;
+struct HPMHookPoint *HP_clif_GlobalMessage_pre;
+struct HPMHookPoint *HP_clif_GlobalMessage_post;
+struct HPMHookPoint *HP_clif_createchat_pre;
+struct HPMHookPoint *HP_clif_createchat_post;
+struct HPMHookPoint *HP_clif_dispchat_pre;
+struct HPMHookPoint *HP_clif_dispchat_post;
+struct HPMHookPoint *HP_clif_joinchatfail_pre;
+struct HPMHookPoint *HP_clif_joinchatfail_post;
+struct HPMHookPoint *HP_clif_joinchatok_pre;
+struct HPMHookPoint *HP_clif_joinchatok_post;
+struct HPMHookPoint *HP_clif_addchat_pre;
+struct HPMHookPoint *HP_clif_addchat_post;
+struct HPMHookPoint *HP_clif_changechatowner_pre;
+struct HPMHookPoint *HP_clif_changechatowner_post;
+struct HPMHookPoint *HP_clif_clearchat_pre;
+struct HPMHookPoint *HP_clif_clearchat_post;
+struct HPMHookPoint *HP_clif_leavechat_pre;
+struct HPMHookPoint *HP_clif_leavechat_post;
+struct HPMHookPoint *HP_clif_changechatstatus_pre;
+struct HPMHookPoint *HP_clif_changechatstatus_post;
+struct HPMHookPoint *HP_clif_wis_message_pre;
+struct HPMHookPoint *HP_clif_wis_message_post;
+struct HPMHookPoint *HP_clif_wis_end_pre;
+struct HPMHookPoint *HP_clif_wis_end_post;
+struct HPMHookPoint *HP_clif_disp_onlyself_pre;
+struct HPMHookPoint *HP_clif_disp_onlyself_post;
+struct HPMHookPoint *HP_clif_disp_message_pre;
+struct HPMHookPoint *HP_clif_disp_message_post;
+struct HPMHookPoint *HP_clif_broadcast_pre;
+struct HPMHookPoint *HP_clif_broadcast_post;
+struct HPMHookPoint *HP_clif_broadcast2_pre;
+struct HPMHookPoint *HP_clif_broadcast2_post;
+struct HPMHookPoint *HP_clif_messagecolor_pre;
+struct HPMHookPoint *HP_clif_messagecolor_post;
+struct HPMHookPoint *HP_clif_disp_overhead_pre;
+struct HPMHookPoint *HP_clif_disp_overhead_post;
+struct HPMHookPoint *HP_clif_msg_pre;
+struct HPMHookPoint *HP_clif_msg_post;
+struct HPMHookPoint *HP_clif_msg_value_pre;
+struct HPMHookPoint *HP_clif_msg_value_post;
+struct HPMHookPoint *HP_clif_msg_skill_pre;
+struct HPMHookPoint *HP_clif_msg_skill_post;
+struct HPMHookPoint *HP_clif_msgtable_pre;
+struct HPMHookPoint *HP_clif_msgtable_post;
+struct HPMHookPoint *HP_clif_msgtable_num_pre;
+struct HPMHookPoint *HP_clif_msgtable_num_post;
+struct HPMHookPoint *HP_clif_message_pre;
+struct HPMHookPoint *HP_clif_message_post;
+struct HPMHookPoint *HP_clif_messageln_pre;
+struct HPMHookPoint *HP_clif_messageln_post;
+struct HPMHookPoint *HP_clif_colormes_pre;
+struct HPMHookPoint *HP_clif_colormes_post;
+struct HPMHookPoint *HP_clif_process_message_pre;
+struct HPMHookPoint *HP_clif_process_message_post;
+struct HPMHookPoint *HP_clif_wisexin_pre;
+struct HPMHookPoint *HP_clif_wisexin_post;
+struct HPMHookPoint *HP_clif_wisall_pre;
+struct HPMHookPoint *HP_clif_wisall_post;
+struct HPMHookPoint *HP_clif_PMIgnoreList_pre;
+struct HPMHookPoint *HP_clif_PMIgnoreList_post;
+struct HPMHookPoint *HP_clif_traderequest_pre;
+struct HPMHookPoint *HP_clif_traderequest_post;
+struct HPMHookPoint *HP_clif_tradestart_pre;
+struct HPMHookPoint *HP_clif_tradestart_post;
+struct HPMHookPoint *HP_clif_tradeadditem_pre;
+struct HPMHookPoint *HP_clif_tradeadditem_post;
+struct HPMHookPoint *HP_clif_tradeitemok_pre;
+struct HPMHookPoint *HP_clif_tradeitemok_post;
+struct HPMHookPoint *HP_clif_tradedeal_lock_pre;
+struct HPMHookPoint *HP_clif_tradedeal_lock_post;
+struct HPMHookPoint *HP_clif_tradecancelled_pre;
+struct HPMHookPoint *HP_clif_tradecancelled_post;
+struct HPMHookPoint *HP_clif_tradecompleted_pre;
+struct HPMHookPoint *HP_clif_tradecompleted_post;
+struct HPMHookPoint *HP_clif_tradeundo_pre;
+struct HPMHookPoint *HP_clif_tradeundo_post;
+struct HPMHookPoint *HP_clif_openvendingreq_pre;
+struct HPMHookPoint *HP_clif_openvendingreq_post;
+struct HPMHookPoint *HP_clif_showvendingboard_pre;
+struct HPMHookPoint *HP_clif_showvendingboard_post;
+struct HPMHookPoint *HP_clif_closevendingboard_pre;
+struct HPMHookPoint *HP_clif_closevendingboard_post;
+struct HPMHookPoint *HP_clif_vendinglist_pre;
+struct HPMHookPoint *HP_clif_vendinglist_post;
+struct HPMHookPoint *HP_clif_buyvending_pre;
+struct HPMHookPoint *HP_clif_buyvending_post;
+struct HPMHookPoint *HP_clif_openvending_pre;
+struct HPMHookPoint *HP_clif_openvending_post;
+struct HPMHookPoint *HP_clif_vendingreport_pre;
+struct HPMHookPoint *HP_clif_vendingreport_post;
+struct HPMHookPoint *HP_clif_storagelist_pre;
+struct HPMHookPoint *HP_clif_storagelist_post;
+struct HPMHookPoint *HP_clif_updatestorageamount_pre;
+struct HPMHookPoint *HP_clif_updatestorageamount_post;
+struct HPMHookPoint *HP_clif_storageitemadded_pre;
+struct HPMHookPoint *HP_clif_storageitemadded_post;
+struct HPMHookPoint *HP_clif_storageitemremoved_pre;
+struct HPMHookPoint *HP_clif_storageitemremoved_post;
+struct HPMHookPoint *HP_clif_storageclose_pre;
+struct HPMHookPoint *HP_clif_storageclose_post;
+struct HPMHookPoint *HP_clif_skillinfoblock_pre;
+struct HPMHookPoint *HP_clif_skillinfoblock_post;
+struct HPMHookPoint *HP_clif_skillup_pre;
+struct HPMHookPoint *HP_clif_skillup_post;
+struct HPMHookPoint *HP_clif_skillinfo_pre;
+struct HPMHookPoint *HP_clif_skillinfo_post;
+struct HPMHookPoint *HP_clif_addskill_pre;
+struct HPMHookPoint *HP_clif_addskill_post;
+struct HPMHookPoint *HP_clif_deleteskill_pre;
+struct HPMHookPoint *HP_clif_deleteskill_post;
+struct HPMHookPoint *HP_clif_party_created_pre;
+struct HPMHookPoint *HP_clif_party_created_post;
+struct HPMHookPoint *HP_clif_party_member_info_pre;
+struct HPMHookPoint *HP_clif_party_member_info_post;
+struct HPMHookPoint *HP_clif_party_info_pre;
+struct HPMHookPoint *HP_clif_party_info_post;
+struct HPMHookPoint *HP_clif_party_invite_pre;
+struct HPMHookPoint *HP_clif_party_invite_post;
+struct HPMHookPoint *HP_clif_party_inviteack_pre;
+struct HPMHookPoint *HP_clif_party_inviteack_post;
+struct HPMHookPoint *HP_clif_party_option_pre;
+struct HPMHookPoint *HP_clif_party_option_post;
+struct HPMHookPoint *HP_clif_party_withdraw_pre;
+struct HPMHookPoint *HP_clif_party_withdraw_post;
+struct HPMHookPoint *HP_clif_party_message_pre;
+struct HPMHookPoint *HP_clif_party_message_post;
+struct HPMHookPoint *HP_clif_party_xy_pre;
+struct HPMHookPoint *HP_clif_party_xy_post;
+struct HPMHookPoint *HP_clif_party_xy_single_pre;
+struct HPMHookPoint *HP_clif_party_xy_single_post;
+struct HPMHookPoint *HP_clif_party_hp_pre;
+struct HPMHookPoint *HP_clif_party_hp_post;
+struct HPMHookPoint *HP_clif_party_xy_remove_pre;
+struct HPMHookPoint *HP_clif_party_xy_remove_post;
+struct HPMHookPoint *HP_clif_party_show_picker_pre;
+struct HPMHookPoint *HP_clif_party_show_picker_post;
+struct HPMHookPoint *HP_clif_partyinvitationstate_pre;
+struct HPMHookPoint *HP_clif_partyinvitationstate_post;
+struct HPMHookPoint *HP_clif_guild_created_pre;
+struct HPMHookPoint *HP_clif_guild_created_post;
+struct HPMHookPoint *HP_clif_guild_belonginfo_pre;
+struct HPMHookPoint *HP_clif_guild_belonginfo_post;
+struct HPMHookPoint *HP_clif_guild_masterormember_pre;
+struct HPMHookPoint *HP_clif_guild_masterormember_post;
+struct HPMHookPoint *HP_clif_guild_basicinfo_pre;
+struct HPMHookPoint *HP_clif_guild_basicinfo_post;
+struct HPMHookPoint *HP_clif_guild_allianceinfo_pre;
+struct HPMHookPoint *HP_clif_guild_allianceinfo_post;
+struct HPMHookPoint *HP_clif_guild_memberlist_pre;
+struct HPMHookPoint *HP_clif_guild_memberlist_post;
+struct HPMHookPoint *HP_clif_guild_skillinfo_pre;
+struct HPMHookPoint *HP_clif_guild_skillinfo_post;
+struct HPMHookPoint *HP_clif_guild_send_onlineinfo_pre;
+struct HPMHookPoint *HP_clif_guild_send_onlineinfo_post;
+struct HPMHookPoint *HP_clif_guild_memberlogin_notice_pre;
+struct HPMHookPoint *HP_clif_guild_memberlogin_notice_post;
+struct HPMHookPoint *HP_clif_guild_invite_pre;
+struct HPMHookPoint *HP_clif_guild_invite_post;
+struct HPMHookPoint *HP_clif_guild_inviteack_pre;
+struct HPMHookPoint *HP_clif_guild_inviteack_post;
+struct HPMHookPoint *HP_clif_guild_leave_pre;
+struct HPMHookPoint *HP_clif_guild_leave_post;
+struct HPMHookPoint *HP_clif_guild_expulsion_pre;
+struct HPMHookPoint *HP_clif_guild_expulsion_post;
+struct HPMHookPoint *HP_clif_guild_positionchanged_pre;
+struct HPMHookPoint *HP_clif_guild_positionchanged_post;
+struct HPMHookPoint *HP_clif_guild_memberpositionchanged_pre;
+struct HPMHookPoint *HP_clif_guild_memberpositionchanged_post;
+struct HPMHookPoint *HP_clif_guild_emblem_pre;
+struct HPMHookPoint *HP_clif_guild_emblem_post;
+struct HPMHookPoint *HP_clif_guild_emblem_area_pre;
+struct HPMHookPoint *HP_clif_guild_emblem_area_post;
+struct HPMHookPoint *HP_clif_guild_notice_pre;
+struct HPMHookPoint *HP_clif_guild_notice_post;
+struct HPMHookPoint *HP_clif_guild_message_pre;
+struct HPMHookPoint *HP_clif_guild_message_post;
+struct HPMHookPoint *HP_clif_guild_skillup_pre;
+struct HPMHookPoint *HP_clif_guild_skillup_post;
+struct HPMHookPoint *HP_clif_guild_reqalliance_pre;
+struct HPMHookPoint *HP_clif_guild_reqalliance_post;
+struct HPMHookPoint *HP_clif_guild_allianceack_pre;
+struct HPMHookPoint *HP_clif_guild_allianceack_post;
+struct HPMHookPoint *HP_clif_guild_delalliance_pre;
+struct HPMHookPoint *HP_clif_guild_delalliance_post;
+struct HPMHookPoint *HP_clif_guild_oppositionack_pre;
+struct HPMHookPoint *HP_clif_guild_oppositionack_post;
+struct HPMHookPoint *HP_clif_guild_broken_pre;
+struct HPMHookPoint *HP_clif_guild_broken_post;
+struct HPMHookPoint *HP_clif_guild_xy_pre;
+struct HPMHookPoint *HP_clif_guild_xy_post;
+struct HPMHookPoint *HP_clif_guild_xy_single_pre;
+struct HPMHookPoint *HP_clif_guild_xy_single_post;
+struct HPMHookPoint *HP_clif_guild_xy_remove_pre;
+struct HPMHookPoint *HP_clif_guild_xy_remove_post;
+struct HPMHookPoint *HP_clif_guild_positionnamelist_pre;
+struct HPMHookPoint *HP_clif_guild_positionnamelist_post;
+struct HPMHookPoint *HP_clif_guild_positioninfolist_pre;
+struct HPMHookPoint *HP_clif_guild_positioninfolist_post;
+struct HPMHookPoint *HP_clif_guild_expulsionlist_pre;
+struct HPMHookPoint *HP_clif_guild_expulsionlist_post;
+struct HPMHookPoint *HP_clif_validate_emblem_pre;
+struct HPMHookPoint *HP_clif_validate_emblem_post;
+struct HPMHookPoint *HP_clif_bg_hp_pre;
+struct HPMHookPoint *HP_clif_bg_hp_post;
+struct HPMHookPoint *HP_clif_bg_xy_pre;
+struct HPMHookPoint *HP_clif_bg_xy_post;
+struct HPMHookPoint *HP_clif_bg_xy_remove_pre;
+struct HPMHookPoint *HP_clif_bg_xy_remove_post;
+struct HPMHookPoint *HP_clif_bg_message_pre;
+struct HPMHookPoint *HP_clif_bg_message_post;
+struct HPMHookPoint *HP_clif_bg_updatescore_pre;
+struct HPMHookPoint *HP_clif_bg_updatescore_post;
+struct HPMHookPoint *HP_clif_bg_updatescore_single_pre;
+struct HPMHookPoint *HP_clif_bg_updatescore_single_post;
+struct HPMHookPoint *HP_clif_sendbgemblem_area_pre;
+struct HPMHookPoint *HP_clif_sendbgemblem_area_post;
+struct HPMHookPoint *HP_clif_sendbgemblem_single_pre;
+struct HPMHookPoint *HP_clif_sendbgemblem_single_post;
+struct HPMHookPoint *HP_clif_instance_pre;
+struct HPMHookPoint *HP_clif_instance_post;
+struct HPMHookPoint *HP_clif_instance_join_pre;
+struct HPMHookPoint *HP_clif_instance_join_post;
+struct HPMHookPoint *HP_clif_instance_leave_pre;
+struct HPMHookPoint *HP_clif_instance_leave_post;
+struct HPMHookPoint *HP_clif_catch_process_pre;
+struct HPMHookPoint *HP_clif_catch_process_post;
+struct HPMHookPoint *HP_clif_pet_roulette_pre;
+struct HPMHookPoint *HP_clif_pet_roulette_post;
+struct HPMHookPoint *HP_clif_sendegg_pre;
+struct HPMHookPoint *HP_clif_sendegg_post;
+struct HPMHookPoint *HP_clif_send_petstatus_pre;
+struct HPMHookPoint *HP_clif_send_petstatus_post;
+struct HPMHookPoint *HP_clif_send_petdata_pre;
+struct HPMHookPoint *HP_clif_send_petdata_post;
+struct HPMHookPoint *HP_clif_pet_emotion_pre;
+struct HPMHookPoint *HP_clif_pet_emotion_post;
+struct HPMHookPoint *HP_clif_pet_food_pre;
+struct HPMHookPoint *HP_clif_pet_food_post;
+struct HPMHookPoint *HP_clif_friendslist_toggle_sub_pre;
+struct HPMHookPoint *HP_clif_friendslist_toggle_sub_post;
+struct HPMHookPoint *HP_clif_friendslist_send_pre;
+struct HPMHookPoint *HP_clif_friendslist_send_post;
+struct HPMHookPoint *HP_clif_friendslist_reqack_pre;
+struct HPMHookPoint *HP_clif_friendslist_reqack_post;
+struct HPMHookPoint *HP_clif_friendslist_toggle_pre;
+struct HPMHookPoint *HP_clif_friendslist_toggle_post;
+struct HPMHookPoint *HP_clif_friendlist_req_pre;
+struct HPMHookPoint *HP_clif_friendlist_req_post;
+struct HPMHookPoint *HP_clif_GM_kickack_pre;
+struct HPMHookPoint *HP_clif_GM_kickack_post;
+struct HPMHookPoint *HP_clif_GM_kick_pre;
+struct HPMHookPoint *HP_clif_GM_kick_post;
+struct HPMHookPoint *HP_clif_manner_message_pre;
+struct HPMHookPoint *HP_clif_manner_message_post;
+struct HPMHookPoint *HP_clif_GM_silence_pre;
+struct HPMHookPoint *HP_clif_GM_silence_post;
+struct HPMHookPoint *HP_clif_account_name_pre;
+struct HPMHookPoint *HP_clif_account_name_post;
+struct HPMHookPoint *HP_clif_check_pre;
+struct HPMHookPoint *HP_clif_check_post;
+struct HPMHookPoint *HP_clif_hominfo_pre;
+struct HPMHookPoint *HP_clif_hominfo_post;
+struct HPMHookPoint *HP_clif_homskillinfoblock_pre;
+struct HPMHookPoint *HP_clif_homskillinfoblock_post;
+struct HPMHookPoint *HP_clif_homskillup_pre;
+struct HPMHookPoint *HP_clif_homskillup_post;
+struct HPMHookPoint *HP_clif_hom_food_pre;
+struct HPMHookPoint *HP_clif_hom_food_post;
+struct HPMHookPoint *HP_clif_send_homdata_pre;
+struct HPMHookPoint *HP_clif_send_homdata_post;
+struct HPMHookPoint *HP_clif_quest_send_list_pre;
+struct HPMHookPoint *HP_clif_quest_send_list_post;
+struct HPMHookPoint *HP_clif_quest_send_mission_pre;
+struct HPMHookPoint *HP_clif_quest_send_mission_post;
+struct HPMHookPoint *HP_clif_quest_add_pre;
+struct HPMHookPoint *HP_clif_quest_add_post;
+struct HPMHookPoint *HP_clif_quest_delete_pre;
+struct HPMHookPoint *HP_clif_quest_delete_post;
+struct HPMHookPoint *HP_clif_quest_update_status_pre;
+struct HPMHookPoint *HP_clif_quest_update_status_post;
+struct HPMHookPoint *HP_clif_quest_update_objective_pre;
+struct HPMHookPoint *HP_clif_quest_update_objective_post;
+struct HPMHookPoint *HP_clif_quest_show_event_pre;
+struct HPMHookPoint *HP_clif_quest_show_event_post;
+struct HPMHookPoint *HP_clif_mail_window_pre;
+struct HPMHookPoint *HP_clif_mail_window_post;
+struct HPMHookPoint *HP_clif_mail_read_pre;
+struct HPMHookPoint *HP_clif_mail_read_post;
+struct HPMHookPoint *HP_clif_mail_delete_pre;
+struct HPMHookPoint *HP_clif_mail_delete_post;
+struct HPMHookPoint *HP_clif_mail_return_pre;
+struct HPMHookPoint *HP_clif_mail_return_post;
+struct HPMHookPoint *HP_clif_mail_send_pre;
+struct HPMHookPoint *HP_clif_mail_send_post;
+struct HPMHookPoint *HP_clif_mail_new_pre;
+struct HPMHookPoint *HP_clif_mail_new_post;
+struct HPMHookPoint *HP_clif_mail_refreshinbox_pre;
+struct HPMHookPoint *HP_clif_mail_refreshinbox_post;
+struct HPMHookPoint *HP_clif_mail_getattachment_pre;
+struct HPMHookPoint *HP_clif_mail_getattachment_post;
+struct HPMHookPoint *HP_clif_mail_setattachment_pre;
+struct HPMHookPoint *HP_clif_mail_setattachment_post;
+struct HPMHookPoint *HP_clif_auction_openwindow_pre;
+struct HPMHookPoint *HP_clif_auction_openwindow_post;
+struct HPMHookPoint *HP_clif_auction_results_pre;
+struct HPMHookPoint *HP_clif_auction_results_post;
+struct HPMHookPoint *HP_clif_auction_message_pre;
+struct HPMHookPoint *HP_clif_auction_message_post;
+struct HPMHookPoint *HP_clif_auction_close_pre;
+struct HPMHookPoint *HP_clif_auction_close_post;
+struct HPMHookPoint *HP_clif_auction_setitem_pre;
+struct HPMHookPoint *HP_clif_auction_setitem_post;
+struct HPMHookPoint *HP_clif_mercenary_info_pre;
+struct HPMHookPoint *HP_clif_mercenary_info_post;
+struct HPMHookPoint *HP_clif_mercenary_skillblock_pre;
+struct HPMHookPoint *HP_clif_mercenary_skillblock_post;
+struct HPMHookPoint *HP_clif_mercenary_message_pre;
+struct HPMHookPoint *HP_clif_mercenary_message_post;
+struct HPMHookPoint *HP_clif_mercenary_updatestatus_pre;
+struct HPMHookPoint *HP_clif_mercenary_updatestatus_post;
+struct HPMHookPoint *HP_clif_rental_time_pre;
+struct HPMHookPoint *HP_clif_rental_time_post;
+struct HPMHookPoint *HP_clif_rental_expired_pre;
+struct HPMHookPoint *HP_clif_rental_expired_post;
+struct HPMHookPoint *HP_clif_PartyBookingRegisterAck_pre;
+struct HPMHookPoint *HP_clif_PartyBookingRegisterAck_post;
+struct HPMHookPoint *HP_clif_PartyBookingDeleteAck_pre;
+struct HPMHookPoint *HP_clif_PartyBookingDeleteAck_post;
+struct HPMHookPoint *HP_clif_PartyBookingSearchAck_pre;
+struct HPMHookPoint *HP_clif_PartyBookingSearchAck_post;
+struct HPMHookPoint *HP_clif_PartyBookingUpdateNotify_pre;
+struct HPMHookPoint *HP_clif_PartyBookingUpdateNotify_post;
+struct HPMHookPoint *HP_clif_PartyBookingDeleteNotify_pre;
+struct HPMHookPoint *HP_clif_PartyBookingDeleteNotify_post;
+struct HPMHookPoint *HP_clif_PartyBookingInsertNotify_pre;
+struct HPMHookPoint *HP_clif_PartyBookingInsertNotify_post;
+struct HPMHookPoint *HP_clif_PartyBookingVolunteerInfo_pre;
+struct HPMHookPoint *HP_clif_PartyBookingVolunteerInfo_post;
+struct HPMHookPoint *HP_clif_PartyBookingRefuseVolunteer_pre;
+struct HPMHookPoint *HP_clif_PartyBookingRefuseVolunteer_post;
+struct HPMHookPoint *HP_clif_PartyBookingCancelVolunteer_pre;
+struct HPMHookPoint *HP_clif_PartyBookingCancelVolunteer_post;
+struct HPMHookPoint *HP_clif_PartyBookingAddFilteringList_pre;
+struct HPMHookPoint *HP_clif_PartyBookingAddFilteringList_post;
+struct HPMHookPoint *HP_clif_PartyBookingSubFilteringList_pre;
+struct HPMHookPoint *HP_clif_PartyBookingSubFilteringList_post;
+struct HPMHookPoint *HP_clif_buyingstore_open_pre;
+struct HPMHookPoint *HP_clif_buyingstore_open_post;
+struct HPMHookPoint *HP_clif_buyingstore_open_failed_pre;
+struct HPMHookPoint *HP_clif_buyingstore_open_failed_post;
+struct HPMHookPoint *HP_clif_buyingstore_myitemlist_pre;
+struct HPMHookPoint *HP_clif_buyingstore_myitemlist_post;
+struct HPMHookPoint *HP_clif_buyingstore_entry_pre;
+struct HPMHookPoint *HP_clif_buyingstore_entry_post;
+struct HPMHookPoint *HP_clif_buyingstore_entry_single_pre;
+struct HPMHookPoint *HP_clif_buyingstore_entry_single_post;
+struct HPMHookPoint *HP_clif_buyingstore_disappear_entry_pre;
+struct HPMHookPoint *HP_clif_buyingstore_disappear_entry_post;
+struct HPMHookPoint *HP_clif_buyingstore_disappear_entry_single_pre;
+struct HPMHookPoint *HP_clif_buyingstore_disappear_entry_single_post;
+struct HPMHookPoint *HP_clif_buyingstore_itemlist_pre;
+struct HPMHookPoint *HP_clif_buyingstore_itemlist_post;
+struct HPMHookPoint *HP_clif_buyingstore_trade_failed_buyer_pre;
+struct HPMHookPoint *HP_clif_buyingstore_trade_failed_buyer_post;
+struct HPMHookPoint *HP_clif_buyingstore_update_item_pre;
+struct HPMHookPoint *HP_clif_buyingstore_update_item_post;
+struct HPMHookPoint *HP_clif_buyingstore_delete_item_pre;
+struct HPMHookPoint *HP_clif_buyingstore_delete_item_post;
+struct HPMHookPoint *HP_clif_buyingstore_trade_failed_seller_pre;
+struct HPMHookPoint *HP_clif_buyingstore_trade_failed_seller_post;
+struct HPMHookPoint *HP_clif_search_store_info_ack_pre;
+struct HPMHookPoint *HP_clif_search_store_info_ack_post;
+struct HPMHookPoint *HP_clif_search_store_info_failed_pre;
+struct HPMHookPoint *HP_clif_search_store_info_failed_post;
+struct HPMHookPoint *HP_clif_open_search_store_info_pre;
+struct HPMHookPoint *HP_clif_open_search_store_info_post;
+struct HPMHookPoint *HP_clif_search_store_info_click_ack_pre;
+struct HPMHookPoint *HP_clif_search_store_info_click_ack_post;
+struct HPMHookPoint *HP_clif_elemental_info_pre;
+struct HPMHookPoint *HP_clif_elemental_info_post;
+struct HPMHookPoint *HP_clif_elemental_updatestatus_pre;
+struct HPMHookPoint *HP_clif_elemental_updatestatus_post;
+struct HPMHookPoint *HP_clif_bgqueue_ack_pre;
+struct HPMHookPoint *HP_clif_bgqueue_ack_post;
+struct HPMHookPoint *HP_clif_bgqueue_notice_delete_pre;
+struct HPMHookPoint *HP_clif_bgqueue_notice_delete_post;
+struct HPMHookPoint *HP_clif_bgqueue_update_info_pre;
+struct HPMHookPoint *HP_clif_bgqueue_update_info_post;
+struct HPMHookPoint *HP_clif_bgqueue_joined_pre;
+struct HPMHookPoint *HP_clif_bgqueue_joined_post;
+struct HPMHookPoint *HP_clif_bgqueue_pcleft_pre;
+struct HPMHookPoint *HP_clif_bgqueue_pcleft_post;
+struct HPMHookPoint *HP_clif_bgqueue_battlebegins_pre;
+struct HPMHookPoint *HP_clif_bgqueue_battlebegins_post;
+struct HPMHookPoint *HP_clif_adopt_reply_pre;
+struct HPMHookPoint *HP_clif_adopt_reply_post;
+struct HPMHookPoint *HP_clif_adopt_request_pre;
+struct HPMHookPoint *HP_clif_adopt_request_post;
+struct HPMHookPoint *HP_clif_readbook_pre;
+struct HPMHookPoint *HP_clif_readbook_post;
+struct HPMHookPoint *HP_clif_notify_time_pre;
+struct HPMHookPoint *HP_clif_notify_time_post;
+struct HPMHookPoint *HP_clif_user_count_pre;
+struct HPMHookPoint *HP_clif_user_count_post;
+struct HPMHookPoint *HP_clif_noask_sub_pre;
+struct HPMHookPoint *HP_clif_noask_sub_post;
+struct HPMHookPoint *HP_clif_bc_ready_pre;
+struct HPMHookPoint *HP_clif_bc_ready_post;
+struct HPMHookPoint *HP_clif_undisguise_timer_pre;
+struct HPMHookPoint *HP_clif_undisguise_timer_post;
+struct HPMHookPoint *HP_clif_chsys_create_pre;
+struct HPMHookPoint *HP_clif_chsys_create_post;
+struct HPMHookPoint *HP_clif_chsys_msg_pre;
+struct HPMHookPoint *HP_clif_chsys_msg_post;
+struct HPMHookPoint *HP_clif_chsys_msg2_pre;
+struct HPMHookPoint *HP_clif_chsys_msg2_post;
+struct HPMHookPoint *HP_clif_chsys_send_pre;
+struct HPMHookPoint *HP_clif_chsys_send_post;
+struct HPMHookPoint *HP_clif_chsys_join_pre;
+struct HPMHookPoint *HP_clif_chsys_join_post;
+struct HPMHookPoint *HP_clif_chsys_left_pre;
+struct HPMHookPoint *HP_clif_chsys_left_post;
+struct HPMHookPoint *HP_clif_chsys_delete_pre;
+struct HPMHookPoint *HP_clif_chsys_delete_post;
+struct HPMHookPoint *HP_clif_chsys_mjoin_pre;
+struct HPMHookPoint *HP_clif_chsys_mjoin_post;
+struct HPMHookPoint *HP_clif_chsys_quit_pre;
+struct HPMHookPoint *HP_clif_chsys_quit_post;
+struct HPMHookPoint *HP_clif_chsys_quitg_pre;
+struct HPMHookPoint *HP_clif_chsys_quitg_post;
+struct HPMHookPoint *HP_clif_chsys_gjoin_pre;
+struct HPMHookPoint *HP_clif_chsys_gjoin_post;
+struct HPMHookPoint *HP_clif_chsys_gleave_pre;
+struct HPMHookPoint *HP_clif_chsys_gleave_post;
+struct HPMHookPoint *HP_clif_pWantToConnection_pre;
+struct HPMHookPoint *HP_clif_pWantToConnection_post;
+struct HPMHookPoint *HP_clif_pLoadEndAck_pre;
+struct HPMHookPoint *HP_clif_pLoadEndAck_post;
+struct HPMHookPoint *HP_clif_pTickSend_pre;
+struct HPMHookPoint *HP_clif_pTickSend_post;
+struct HPMHookPoint *HP_clif_pHotkey_pre;
+struct HPMHookPoint *HP_clif_pHotkey_post;
+struct HPMHookPoint *HP_clif_pProgressbar_pre;
+struct HPMHookPoint *HP_clif_pProgressbar_post;
+struct HPMHookPoint *HP_clif_pWalkToXY_pre;
+struct HPMHookPoint *HP_clif_pWalkToXY_post;
+struct HPMHookPoint *HP_clif_pQuitGame_pre;
+struct HPMHookPoint *HP_clif_pQuitGame_post;
+struct HPMHookPoint *HP_clif_pGetCharNameRequest_pre;
+struct HPMHookPoint *HP_clif_pGetCharNameRequest_post;
+struct HPMHookPoint *HP_clif_pGlobalMessage_pre;
+struct HPMHookPoint *HP_clif_pGlobalMessage_post;
+struct HPMHookPoint *HP_clif_pMapMove_pre;
+struct HPMHookPoint *HP_clif_pMapMove_post;
+struct HPMHookPoint *HP_clif_pChangeDir_pre;
+struct HPMHookPoint *HP_clif_pChangeDir_post;
+struct HPMHookPoint *HP_clif_pEmotion_pre;
+struct HPMHookPoint *HP_clif_pEmotion_post;
+struct HPMHookPoint *HP_clif_pHowManyConnections_pre;
+struct HPMHookPoint *HP_clif_pHowManyConnections_post;
+struct HPMHookPoint *HP_clif_pActionRequest_pre;
+struct HPMHookPoint *HP_clif_pActionRequest_post;
+struct HPMHookPoint *HP_clif_pActionRequest_sub_pre;
+struct HPMHookPoint *HP_clif_pActionRequest_sub_post;
+struct HPMHookPoint *HP_clif_pRestart_pre;
+struct HPMHookPoint *HP_clif_pRestart_post;
+struct HPMHookPoint *HP_clif_pWisMessage_pre;
+struct HPMHookPoint *HP_clif_pWisMessage_post;
+struct HPMHookPoint *HP_clif_pBroadcast_pre;
+struct HPMHookPoint *HP_clif_pBroadcast_post;
+struct HPMHookPoint *HP_clif_pTakeItem_pre;
+struct HPMHookPoint *HP_clif_pTakeItem_post;
+struct HPMHookPoint *HP_clif_pDropItem_pre;
+struct HPMHookPoint *HP_clif_pDropItem_post;
+struct HPMHookPoint *HP_clif_pUseItem_pre;
+struct HPMHookPoint *HP_clif_pUseItem_post;
+struct HPMHookPoint *HP_clif_pEquipItem_pre;
+struct HPMHookPoint *HP_clif_pEquipItem_post;
+struct HPMHookPoint *HP_clif_pUnequipItem_pre;
+struct HPMHookPoint *HP_clif_pUnequipItem_post;
+struct HPMHookPoint *HP_clif_pNpcClicked_pre;
+struct HPMHookPoint *HP_clif_pNpcClicked_post;
+struct HPMHookPoint *HP_clif_pNpcBuySellSelected_pre;
+struct HPMHookPoint *HP_clif_pNpcBuySellSelected_post;
+struct HPMHookPoint *HP_clif_pNpcBuyListSend_pre;
+struct HPMHookPoint *HP_clif_pNpcBuyListSend_post;
+struct HPMHookPoint *HP_clif_pNpcSellListSend_pre;
+struct HPMHookPoint *HP_clif_pNpcSellListSend_post;
+struct HPMHookPoint *HP_clif_pCreateChatRoom_pre;
+struct HPMHookPoint *HP_clif_pCreateChatRoom_post;
+struct HPMHookPoint *HP_clif_pChatAddMember_pre;
+struct HPMHookPoint *HP_clif_pChatAddMember_post;
+struct HPMHookPoint *HP_clif_pChatRoomStatusChange_pre;
+struct HPMHookPoint *HP_clif_pChatRoomStatusChange_post;
+struct HPMHookPoint *HP_clif_pChangeChatOwner_pre;
+struct HPMHookPoint *HP_clif_pChangeChatOwner_post;
+struct HPMHookPoint *HP_clif_pKickFromChat_pre;
+struct HPMHookPoint *HP_clif_pKickFromChat_post;
+struct HPMHookPoint *HP_clif_pChatLeave_pre;
+struct HPMHookPoint *HP_clif_pChatLeave_post;
+struct HPMHookPoint *HP_clif_pTradeRequest_pre;
+struct HPMHookPoint *HP_clif_pTradeRequest_post;
+struct HPMHookPoint *HP_clif_chann_config_read_pre;
+struct HPMHookPoint *HP_clif_chann_config_read_post;
+struct HPMHookPoint *HP_clif_pTradeAck_pre;
+struct HPMHookPoint *HP_clif_pTradeAck_post;
+struct HPMHookPoint *HP_clif_pTradeAddItem_pre;
+struct HPMHookPoint *HP_clif_pTradeAddItem_post;
+struct HPMHookPoint *HP_clif_pTradeOk_pre;
+struct HPMHookPoint *HP_clif_pTradeOk_post;
+struct HPMHookPoint *HP_clif_pTradeCancel_pre;
+struct HPMHookPoint *HP_clif_pTradeCancel_post;
+struct HPMHookPoint *HP_clif_pTradeCommit_pre;
+struct HPMHookPoint *HP_clif_pTradeCommit_post;
+struct HPMHookPoint *HP_clif_pStopAttack_pre;
+struct HPMHookPoint *HP_clif_pStopAttack_post;
+struct HPMHookPoint *HP_clif_pPutItemToCart_pre;
+struct HPMHookPoint *HP_clif_pPutItemToCart_post;
+struct HPMHookPoint *HP_clif_pGetItemFromCart_pre;
+struct HPMHookPoint *HP_clif_pGetItemFromCart_post;
+struct HPMHookPoint *HP_clif_pRemoveOption_pre;
+struct HPMHookPoint *HP_clif_pRemoveOption_post;
+struct HPMHookPoint *HP_clif_pChangeCart_pre;
+struct HPMHookPoint *HP_clif_pChangeCart_post;
+struct HPMHookPoint *HP_clif_pStatusUp_pre;
+struct HPMHookPoint *HP_clif_pStatusUp_post;
+struct HPMHookPoint *HP_clif_pSkillUp_pre;
+struct HPMHookPoint *HP_clif_pSkillUp_post;
+struct HPMHookPoint *HP_clif_pUseSkillToId_pre;
+struct HPMHookPoint *HP_clif_pUseSkillToId_post;
+struct HPMHookPoint *HP_clif_pUseSkillToId_homun_pre;
+struct HPMHookPoint *HP_clif_pUseSkillToId_homun_post;
+struct HPMHookPoint *HP_clif_pUseSkillToId_mercenary_pre;
+struct HPMHookPoint *HP_clif_pUseSkillToId_mercenary_post;
+struct HPMHookPoint *HP_clif_pUseSkillToPos_pre;
+struct HPMHookPoint *HP_clif_pUseSkillToPos_post;
+struct HPMHookPoint *HP_clif_pUseSkillToPosSub_pre;
+struct HPMHookPoint *HP_clif_pUseSkillToPosSub_post;
+struct HPMHookPoint *HP_clif_pUseSkillToPos_homun_pre;
+struct HPMHookPoint *HP_clif_pUseSkillToPos_homun_post;
+struct HPMHookPoint *HP_clif_pUseSkillToPos_mercenary_pre;
+struct HPMHookPoint *HP_clif_pUseSkillToPos_mercenary_post;
+struct HPMHookPoint *HP_clif_pUseSkillToPosMoreInfo_pre;
+struct HPMHookPoint *HP_clif_pUseSkillToPosMoreInfo_post;
+struct HPMHookPoint *HP_clif_pUseSkillMap_pre;
+struct HPMHookPoint *HP_clif_pUseSkillMap_post;
+struct HPMHookPoint *HP_clif_pRequestMemo_pre;
+struct HPMHookPoint *HP_clif_pRequestMemo_post;
+struct HPMHookPoint *HP_clif_pProduceMix_pre;
+struct HPMHookPoint *HP_clif_pProduceMix_post;
+struct HPMHookPoint *HP_clif_pCooking_pre;
+struct HPMHookPoint *HP_clif_pCooking_post;
+struct HPMHookPoint *HP_clif_pRepairItem_pre;
+struct HPMHookPoint *HP_clif_pRepairItem_post;
+struct HPMHookPoint *HP_clif_pWeaponRefine_pre;
+struct HPMHookPoint *HP_clif_pWeaponRefine_post;
+struct HPMHookPoint *HP_clif_pNpcSelectMenu_pre;
+struct HPMHookPoint *HP_clif_pNpcSelectMenu_post;
+struct HPMHookPoint *HP_clif_pNpcNextClicked_pre;
+struct HPMHookPoint *HP_clif_pNpcNextClicked_post;
+struct HPMHookPoint *HP_clif_pNpcAmountInput_pre;
+struct HPMHookPoint *HP_clif_pNpcAmountInput_post;
+struct HPMHookPoint *HP_clif_pNpcStringInput_pre;
+struct HPMHookPoint *HP_clif_pNpcStringInput_post;
+struct HPMHookPoint *HP_clif_pNpcCloseClicked_pre;
+struct HPMHookPoint *HP_clif_pNpcCloseClicked_post;
+struct HPMHookPoint *HP_clif_pItemIdentify_pre;
+struct HPMHookPoint *HP_clif_pItemIdentify_post;
+struct HPMHookPoint *HP_clif_pSelectArrow_pre;
+struct HPMHookPoint *HP_clif_pSelectArrow_post;
+struct HPMHookPoint *HP_clif_pAutoSpell_pre;
+struct HPMHookPoint *HP_clif_pAutoSpell_post;
+struct HPMHookPoint *HP_clif_pUseCard_pre;
+struct HPMHookPoint *HP_clif_pUseCard_post;
+struct HPMHookPoint *HP_clif_pInsertCard_pre;
+struct HPMHookPoint *HP_clif_pInsertCard_post;
+struct HPMHookPoint *HP_clif_pSolveCharName_pre;
+struct HPMHookPoint *HP_clif_pSolveCharName_post;
+struct HPMHookPoint *HP_clif_pResetChar_pre;
+struct HPMHookPoint *HP_clif_pResetChar_post;
+struct HPMHookPoint *HP_clif_pLocalBroadcast_pre;
+struct HPMHookPoint *HP_clif_pLocalBroadcast_post;
+struct HPMHookPoint *HP_clif_pMoveToKafra_pre;
+struct HPMHookPoint *HP_clif_pMoveToKafra_post;
+struct HPMHookPoint *HP_clif_pMoveFromKafra_pre;
+struct HPMHookPoint *HP_clif_pMoveFromKafra_post;
+struct HPMHookPoint *HP_clif_pMoveToKafraFromCart_pre;
+struct HPMHookPoint *HP_clif_pMoveToKafraFromCart_post;
+struct HPMHookPoint *HP_clif_pMoveFromKafraToCart_pre;
+struct HPMHookPoint *HP_clif_pMoveFromKafraToCart_post;
+struct HPMHookPoint *HP_clif_pCloseKafra_pre;
+struct HPMHookPoint *HP_clif_pCloseKafra_post;
+struct HPMHookPoint *HP_clif_pStoragePassword_pre;
+struct HPMHookPoint *HP_clif_pStoragePassword_post;
+struct HPMHookPoint *HP_clif_pCreateParty_pre;
+struct HPMHookPoint *HP_clif_pCreateParty_post;
+struct HPMHookPoint *HP_clif_pCreateParty2_pre;
+struct HPMHookPoint *HP_clif_pCreateParty2_post;
+struct HPMHookPoint *HP_clif_pPartyInvite_pre;
+struct HPMHookPoint *HP_clif_pPartyInvite_post;
+struct HPMHookPoint *HP_clif_pPartyInvite2_pre;
+struct HPMHookPoint *HP_clif_pPartyInvite2_post;
+struct HPMHookPoint *HP_clif_pReplyPartyInvite_pre;
+struct HPMHookPoint *HP_clif_pReplyPartyInvite_post;
+struct HPMHookPoint *HP_clif_pReplyPartyInvite2_pre;
+struct HPMHookPoint *HP_clif_pReplyPartyInvite2_post;
+struct HPMHookPoint *HP_clif_pLeaveParty_pre;
+struct HPMHookPoint *HP_clif_pLeaveParty_post;
+struct HPMHookPoint *HP_clif_pRemovePartyMember_pre;
+struct HPMHookPoint *HP_clif_pRemovePartyMember_post;
+struct HPMHookPoint *HP_clif_pPartyChangeOption_pre;
+struct HPMHookPoint *HP_clif_pPartyChangeOption_post;
+struct HPMHookPoint *HP_clif_pPartyMessage_pre;
+struct HPMHookPoint *HP_clif_pPartyMessage_post;
+struct HPMHookPoint *HP_clif_pPartyChangeLeader_pre;
+struct HPMHookPoint *HP_clif_pPartyChangeLeader_post;
+struct HPMHookPoint *HP_clif_pPartyBookingRegisterReq_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingRegisterReq_post;
+struct HPMHookPoint *HP_clif_pPartyBookingSearchReq_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingSearchReq_post;
+struct HPMHookPoint *HP_clif_pPartyBookingDeleteReq_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingDeleteReq_post;
+struct HPMHookPoint *HP_clif_pPartyBookingUpdateReq_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingUpdateReq_post;
+struct HPMHookPoint *HP_clif_pCloseVending_pre;
+struct HPMHookPoint *HP_clif_pCloseVending_post;
+struct HPMHookPoint *HP_clif_pVendingListReq_pre;
+struct HPMHookPoint *HP_clif_pVendingListReq_post;
+struct HPMHookPoint *HP_clif_pPurchaseReq_pre;
+struct HPMHookPoint *HP_clif_pPurchaseReq_post;
+struct HPMHookPoint *HP_clif_pPurchaseReq2_pre;
+struct HPMHookPoint *HP_clif_pPurchaseReq2_post;
+struct HPMHookPoint *HP_clif_pOpenVending_pre;
+struct HPMHookPoint *HP_clif_pOpenVending_post;
+struct HPMHookPoint *HP_clif_pCreateGuild_pre;
+struct HPMHookPoint *HP_clif_pCreateGuild_post;
+struct HPMHookPoint *HP_clif_pGuildCheckMaster_pre;
+struct HPMHookPoint *HP_clif_pGuildCheckMaster_post;
+struct HPMHookPoint *HP_clif_pGuildRequestInfo_pre;
+struct HPMHookPoint *HP_clif_pGuildRequestInfo_post;
+struct HPMHookPoint *HP_clif_pGuildChangePositionInfo_pre;
+struct HPMHookPoint *HP_clif_pGuildChangePositionInfo_post;
+struct HPMHookPoint *HP_clif_pGuildChangeMemberPosition_pre;
+struct HPMHookPoint *HP_clif_pGuildChangeMemberPosition_post;
+struct HPMHookPoint *HP_clif_pGuildRequestEmblem_pre;
+struct HPMHookPoint *HP_clif_pGuildRequestEmblem_post;
+struct HPMHookPoint *HP_clif_pGuildChangeEmblem_pre;
+struct HPMHookPoint *HP_clif_pGuildChangeEmblem_post;
+struct HPMHookPoint *HP_clif_pGuildChangeNotice_pre;
+struct HPMHookPoint *HP_clif_pGuildChangeNotice_post;
+struct HPMHookPoint *HP_clif_pGuildInvite_pre;
+struct HPMHookPoint *HP_clif_pGuildInvite_post;
+struct HPMHookPoint *HP_clif_pGuildReplyInvite_pre;
+struct HPMHookPoint *HP_clif_pGuildReplyInvite_post;
+struct HPMHookPoint *HP_clif_pGuildLeave_pre;
+struct HPMHookPoint *HP_clif_pGuildLeave_post;
+struct HPMHookPoint *HP_clif_pGuildExpulsion_pre;
+struct HPMHookPoint *HP_clif_pGuildExpulsion_post;
+struct HPMHookPoint *HP_clif_pGuildMessage_pre;
+struct HPMHookPoint *HP_clif_pGuildMessage_post;
+struct HPMHookPoint *HP_clif_pGuildRequestAlliance_pre;
+struct HPMHookPoint *HP_clif_pGuildRequestAlliance_post;
+struct HPMHookPoint *HP_clif_pGuildReplyAlliance_pre;
+struct HPMHookPoint *HP_clif_pGuildReplyAlliance_post;
+struct HPMHookPoint *HP_clif_pGuildDelAlliance_pre;
+struct HPMHookPoint *HP_clif_pGuildDelAlliance_post;
+struct HPMHookPoint *HP_clif_pGuildOpposition_pre;
+struct HPMHookPoint *HP_clif_pGuildOpposition_post;
+struct HPMHookPoint *HP_clif_pGuildBreak_pre;
+struct HPMHookPoint *HP_clif_pGuildBreak_post;
+struct HPMHookPoint *HP_clif_pPetMenu_pre;
+struct HPMHookPoint *HP_clif_pPetMenu_post;
+struct HPMHookPoint *HP_clif_pCatchPet_pre;
+struct HPMHookPoint *HP_clif_pCatchPet_post;
+struct HPMHookPoint *HP_clif_pSelectEgg_pre;
+struct HPMHookPoint *HP_clif_pSelectEgg_post;
+struct HPMHookPoint *HP_clif_pSendEmotion_pre;
+struct HPMHookPoint *HP_clif_pSendEmotion_post;
+struct HPMHookPoint *HP_clif_pChangePetName_pre;
+struct HPMHookPoint *HP_clif_pChangePetName_post;
+struct HPMHookPoint *HP_clif_pGMKick_pre;
+struct HPMHookPoint *HP_clif_pGMKick_post;
+struct HPMHookPoint *HP_clif_pGMKickAll_pre;
+struct HPMHookPoint *HP_clif_pGMKickAll_post;
+struct HPMHookPoint *HP_clif_pGMShift_pre;
+struct HPMHookPoint *HP_clif_pGMShift_post;
+struct HPMHookPoint *HP_clif_pGMRemove2_pre;
+struct HPMHookPoint *HP_clif_pGMRemove2_post;
+struct HPMHookPoint *HP_clif_pGMRecall_pre;
+struct HPMHookPoint *HP_clif_pGMRecall_post;
+struct HPMHookPoint *HP_clif_pGMRecall2_pre;
+struct HPMHookPoint *HP_clif_pGMRecall2_post;
+struct HPMHookPoint *HP_clif_pGM_Monster_Item_pre;
+struct HPMHookPoint *HP_clif_pGM_Monster_Item_post;
+struct HPMHookPoint *HP_clif_pGMHide_pre;
+struct HPMHookPoint *HP_clif_pGMHide_post;
+struct HPMHookPoint *HP_clif_pGMReqNoChat_pre;
+struct HPMHookPoint *HP_clif_pGMReqNoChat_post;
+struct HPMHookPoint *HP_clif_pGMRc_pre;
+struct HPMHookPoint *HP_clif_pGMRc_post;
+struct HPMHookPoint *HP_clif_pGMReqAccountName_pre;
+struct HPMHookPoint *HP_clif_pGMReqAccountName_post;
+struct HPMHookPoint *HP_clif_pGMChangeMapType_pre;
+struct HPMHookPoint *HP_clif_pGMChangeMapType_post;
+struct HPMHookPoint *HP_clif_pPMIgnore_pre;
+struct HPMHookPoint *HP_clif_pPMIgnore_post;
+struct HPMHookPoint *HP_clif_pPMIgnoreAll_pre;
+struct HPMHookPoint *HP_clif_pPMIgnoreAll_post;
+struct HPMHookPoint *HP_clif_pPMIgnoreList_pre;
+struct HPMHookPoint *HP_clif_pPMIgnoreList_post;
+struct HPMHookPoint *HP_clif_pNoviceDoriDori_pre;
+struct HPMHookPoint *HP_clif_pNoviceDoriDori_post;
+struct HPMHookPoint *HP_clif_pNoviceExplosionSpirits_pre;
+struct HPMHookPoint *HP_clif_pNoviceExplosionSpirits_post;
+struct HPMHookPoint *HP_clif_pFriendsListAdd_pre;
+struct HPMHookPoint *HP_clif_pFriendsListAdd_post;
+struct HPMHookPoint *HP_clif_pFriendsListReply_pre;
+struct HPMHookPoint *HP_clif_pFriendsListReply_post;
+struct HPMHookPoint *HP_clif_pFriendsListRemove_pre;
+struct HPMHookPoint *HP_clif_pFriendsListRemove_post;
+struct HPMHookPoint *HP_clif_pPVPInfo_pre;
+struct HPMHookPoint *HP_clif_pPVPInfo_post;
+struct HPMHookPoint *HP_clif_pBlacksmith_pre;
+struct HPMHookPoint *HP_clif_pBlacksmith_post;
+struct HPMHookPoint *HP_clif_pAlchemist_pre;
+struct HPMHookPoint *HP_clif_pAlchemist_post;
+struct HPMHookPoint *HP_clif_pTaekwon_pre;
+struct HPMHookPoint *HP_clif_pTaekwon_post;
+struct HPMHookPoint *HP_clif_pRankingPk_pre;
+struct HPMHookPoint *HP_clif_pRankingPk_post;
+struct HPMHookPoint *HP_clif_pFeelSaveOk_pre;
+struct HPMHookPoint *HP_clif_pFeelSaveOk_post;
+struct HPMHookPoint *HP_clif_pChangeHomunculusName_pre;
+struct HPMHookPoint *HP_clif_pChangeHomunculusName_post;
+struct HPMHookPoint *HP_clif_pHomMoveToMaster_pre;
+struct HPMHookPoint *HP_clif_pHomMoveToMaster_post;
+struct HPMHookPoint *HP_clif_pHomMoveTo_pre;
+struct HPMHookPoint *HP_clif_pHomMoveTo_post;
+struct HPMHookPoint *HP_clif_pHomAttack_pre;
+struct HPMHookPoint *HP_clif_pHomAttack_post;
+struct HPMHookPoint *HP_clif_pHomMenu_pre;
+struct HPMHookPoint *HP_clif_pHomMenu_post;
+struct HPMHookPoint *HP_clif_pAutoRevive_pre;
+struct HPMHookPoint *HP_clif_pAutoRevive_post;
+struct HPMHookPoint *HP_clif_pCheck_pre;
+struct HPMHookPoint *HP_clif_pCheck_post;
+struct HPMHookPoint *HP_clif_pMail_refreshinbox_pre;
+struct HPMHookPoint *HP_clif_pMail_refreshinbox_post;
+struct HPMHookPoint *HP_clif_pMail_read_pre;
+struct HPMHookPoint *HP_clif_pMail_read_post;
+struct HPMHookPoint *HP_clif_pMail_getattach_pre;
+struct HPMHookPoint *HP_clif_pMail_getattach_post;
+struct HPMHookPoint *HP_clif_pMail_delete_pre;
+struct HPMHookPoint *HP_clif_pMail_delete_post;
+struct HPMHookPoint *HP_clif_pMail_return_pre;
+struct HPMHookPoint *HP_clif_pMail_return_post;
+struct HPMHookPoint *HP_clif_pMail_setattach_pre;
+struct HPMHookPoint *HP_clif_pMail_setattach_post;
+struct HPMHookPoint *HP_clif_pMail_winopen_pre;
+struct HPMHookPoint *HP_clif_pMail_winopen_post;
+struct HPMHookPoint *HP_clif_pMail_send_pre;
+struct HPMHookPoint *HP_clif_pMail_send_post;
+struct HPMHookPoint *HP_clif_pAuction_cancelreg_pre;
+struct HPMHookPoint *HP_clif_pAuction_cancelreg_post;
+struct HPMHookPoint *HP_clif_pAuction_setitem_pre;
+struct HPMHookPoint *HP_clif_pAuction_setitem_post;
+struct HPMHookPoint *HP_clif_pAuction_register_pre;
+struct HPMHookPoint *HP_clif_pAuction_register_post;
+struct HPMHookPoint *HP_clif_pAuction_cancel_pre;
+struct HPMHookPoint *HP_clif_pAuction_cancel_post;
+struct HPMHookPoint *HP_clif_pAuction_close_pre;
+struct HPMHookPoint *HP_clif_pAuction_close_post;
+struct HPMHookPoint *HP_clif_pAuction_bid_pre;
+struct HPMHookPoint *HP_clif_pAuction_bid_post;
+struct HPMHookPoint *HP_clif_pAuction_search_pre;
+struct HPMHookPoint *HP_clif_pAuction_search_post;
+struct HPMHookPoint *HP_clif_pAuction_buysell_pre;
+struct HPMHookPoint *HP_clif_pAuction_buysell_post;
+struct HPMHookPoint *HP_clif_pcashshop_buy_pre;
+struct HPMHookPoint *HP_clif_pcashshop_buy_post;
+struct HPMHookPoint *HP_clif_pAdopt_request_pre;
+struct HPMHookPoint *HP_clif_pAdopt_request_post;
+struct HPMHookPoint *HP_clif_pAdopt_reply_pre;
+struct HPMHookPoint *HP_clif_pAdopt_reply_post;
+struct HPMHookPoint *HP_clif_pViewPlayerEquip_pre;
+struct HPMHookPoint *HP_clif_pViewPlayerEquip_post;
+struct HPMHookPoint *HP_clif_pEquipTick_pre;
+struct HPMHookPoint *HP_clif_pEquipTick_post;
+struct HPMHookPoint *HP_clif_pquestStateAck_pre;
+struct HPMHookPoint *HP_clif_pquestStateAck_post;
+struct HPMHookPoint *HP_clif_pmercenary_action_pre;
+struct HPMHookPoint *HP_clif_pmercenary_action_post;
+struct HPMHookPoint *HP_clif_pBattleChat_pre;
+struct HPMHookPoint *HP_clif_pBattleChat_post;
+struct HPMHookPoint *HP_clif_pLessEffect_pre;
+struct HPMHookPoint *HP_clif_pLessEffect_post;
+struct HPMHookPoint *HP_clif_pItemListWindowSelected_pre;
+struct HPMHookPoint *HP_clif_pItemListWindowSelected_post;
+struct HPMHookPoint *HP_clif_pReqOpenBuyingStore_pre;
+struct HPMHookPoint *HP_clif_pReqOpenBuyingStore_post;
+struct HPMHookPoint *HP_clif_pReqCloseBuyingStore_pre;
+struct HPMHookPoint *HP_clif_pReqCloseBuyingStore_post;
+struct HPMHookPoint *HP_clif_pReqClickBuyingStore_pre;
+struct HPMHookPoint *HP_clif_pReqClickBuyingStore_post;
+struct HPMHookPoint *HP_clif_pReqTradeBuyingStore_pre;
+struct HPMHookPoint *HP_clif_pReqTradeBuyingStore_post;
+struct HPMHookPoint *HP_clif_pSearchStoreInfo_pre;
+struct HPMHookPoint *HP_clif_pSearchStoreInfo_post;
+struct HPMHookPoint *HP_clif_pSearchStoreInfoNextPage_pre;
+struct HPMHookPoint *HP_clif_pSearchStoreInfoNextPage_post;
+struct HPMHookPoint *HP_clif_pCloseSearchStoreInfo_pre;
+struct HPMHookPoint *HP_clif_pCloseSearchStoreInfo_post;
+struct HPMHookPoint *HP_clif_pSearchStoreInfoListItemClick_pre;
+struct HPMHookPoint *HP_clif_pSearchStoreInfoListItemClick_post;
+struct HPMHookPoint *HP_clif_pDebug_pre;
+struct HPMHookPoint *HP_clif_pDebug_post;
+struct HPMHookPoint *HP_clif_pSkillSelectMenu_pre;
+struct HPMHookPoint *HP_clif_pSkillSelectMenu_post;
+struct HPMHookPoint *HP_clif_pMoveItem_pre;
+struct HPMHookPoint *HP_clif_pMoveItem_post;
+struct HPMHookPoint *HP_clif_pDull_pre;
+struct HPMHookPoint *HP_clif_pDull_post;
+struct HPMHookPoint *HP_clif_pBGQueueRegister_pre;
+struct HPMHookPoint *HP_clif_pBGQueueRegister_post;
+struct HPMHookPoint *HP_clif_pBGQueueCheckState_pre;
+struct HPMHookPoint *HP_clif_pBGQueueCheckState_post;
+struct HPMHookPoint *HP_clif_pBGQueueRevokeReq_pre;
+struct HPMHookPoint *HP_clif_pBGQueueRevokeReq_post;
+struct HPMHookPoint *HP_clif_pBGQueueBattleBeginAck_pre;
+struct HPMHookPoint *HP_clif_pBGQueueBattleBeginAck_post;
+struct HPMHookPoint *HP_clif_pCashShopOpen_pre;
+struct HPMHookPoint *HP_clif_pCashShopOpen_post;
+struct HPMHookPoint *HP_clif_pCashShopClose_pre;
+struct HPMHookPoint *HP_clif_pCashShopClose_post;
+struct HPMHookPoint *HP_clif_pCashShopReqTab_pre;
+struct HPMHookPoint *HP_clif_pCashShopReqTab_post;
+struct HPMHookPoint *HP_clif_pCashShopSchedule_pre;
+struct HPMHookPoint *HP_clif_pCashShopSchedule_post;
+struct HPMHookPoint *HP_clif_pCashShopBuy_pre;
+struct HPMHookPoint *HP_clif_pCashShopBuy_post;
+struct HPMHookPoint *HP_clif_pPartyTick_pre;
+struct HPMHookPoint *HP_clif_pPartyTick_post;
+struct HPMHookPoint *HP_clif_pGuildInvite2_pre;
+struct HPMHookPoint *HP_clif_pGuildInvite2_post;
+struct HPMHookPoint *HP_clif_pPartyBookingAddFilter_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingAddFilter_post;
+struct HPMHookPoint *HP_clif_pPartyBookingSubFilter_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingSubFilter_post;
+struct HPMHookPoint *HP_clif_pPartyBookingReqVolunteer_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingReqVolunteer_post;
+struct HPMHookPoint *HP_clif_pPartyBookingRefuseVolunteer_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingRefuseVolunteer_post;
+struct HPMHookPoint *HP_clif_pPartyBookingCancelVolunteer_pre;
+struct HPMHookPoint *HP_clif_pPartyBookingCancelVolunteer_post;
+struct HPMHookPoint *HP_duel_create_pre;
+struct HPMHookPoint *HP_duel_create_post;
+struct HPMHookPoint *HP_duel_invite_pre;
+struct HPMHookPoint *HP_duel_invite_post;
+struct HPMHookPoint *HP_duel_accept_pre;
+struct HPMHookPoint *HP_duel_accept_post;
+struct HPMHookPoint *HP_duel_reject_pre;
+struct HPMHookPoint *HP_duel_reject_post;
+struct HPMHookPoint *HP_duel_leave_pre;
+struct HPMHookPoint *HP_duel_leave_post;
+struct HPMHookPoint *HP_duel_showinfo_pre;
+struct HPMHookPoint *HP_duel_showinfo_post;
+struct HPMHookPoint *HP_duel_checktime_pre;
+struct HPMHookPoint *HP_duel_checktime_post;
+struct HPMHookPoint *HP_duel_init_pre;
+struct HPMHookPoint *HP_duel_init_post;
+struct HPMHookPoint *HP_duel_final_pre;
+struct HPMHookPoint *HP_duel_final_post;
+struct HPMHookPoint *HP_elemental_init_pre;
+struct HPMHookPoint *HP_elemental_init_post;
+struct HPMHookPoint *HP_elemental_final_pre;
+struct HPMHookPoint *HP_elemental_final_post;
+struct HPMHookPoint *HP_elemental_class_pre;
+struct HPMHookPoint *HP_elemental_class_post;
+struct HPMHookPoint *HP_elemental_get_viewdata_pre;
+struct HPMHookPoint *HP_elemental_get_viewdata_post;
+struct HPMHookPoint *HP_elemental_create_pre;
+struct HPMHookPoint *HP_elemental_create_post;
+struct HPMHookPoint *HP_elemental_data_received_pre;
+struct HPMHookPoint *HP_elemental_data_received_post;
+struct HPMHookPoint *HP_elemental_save_pre;
+struct HPMHookPoint *HP_elemental_save_post;
+struct HPMHookPoint *HP_elemental_change_mode_ack_pre;
+struct HPMHookPoint *HP_elemental_change_mode_ack_post;
+struct HPMHookPoint *HP_elemental_change_mode_pre;
+struct HPMHookPoint *HP_elemental_change_mode_post;
+struct HPMHookPoint *HP_elemental_heal_pre;
+struct HPMHookPoint *HP_elemental_heal_post;
+struct HPMHookPoint *HP_elemental_dead_pre;
+struct HPMHookPoint *HP_elemental_dead_post;
+struct HPMHookPoint *HP_elemental_delete_pre;
+struct HPMHookPoint *HP_elemental_delete_post;
+struct HPMHookPoint *HP_elemental_summon_stop_pre;
+struct HPMHookPoint *HP_elemental_summon_stop_post;
+struct HPMHookPoint *HP_elemental_get_lifetime_pre;
+struct HPMHookPoint *HP_elemental_get_lifetime_post;
+struct HPMHookPoint *HP_elemental_unlocktarget_pre;
+struct HPMHookPoint *HP_elemental_unlocktarget_post;
+struct HPMHookPoint *HP_elemental_skillnotok_pre;
+struct HPMHookPoint *HP_elemental_skillnotok_post;
+struct HPMHookPoint *HP_elemental_set_target_pre;
+struct HPMHookPoint *HP_elemental_set_target_post;
+struct HPMHookPoint *HP_elemental_clean_single_effect_pre;
+struct HPMHookPoint *HP_elemental_clean_single_effect_post;
+struct HPMHookPoint *HP_elemental_clean_effect_pre;
+struct HPMHookPoint *HP_elemental_clean_effect_post;
+struct HPMHookPoint *HP_elemental_action_pre;
+struct HPMHookPoint *HP_elemental_action_post;
+struct HPMHookPoint *HP_elemental_skill_get_requirements_pre;
+struct HPMHookPoint *HP_elemental_skill_get_requirements_post;
+struct HPMHookPoint *HP_elemental_read_skilldb_pre;
+struct HPMHookPoint *HP_elemental_read_skilldb_post;
+struct HPMHookPoint *HP_elemental_reload_db_pre;
+struct HPMHookPoint *HP_elemental_reload_db_post;
+struct HPMHookPoint *HP_elemental_reload_skilldb_pre;
+struct HPMHookPoint *HP_elemental_reload_skilldb_post;
+struct HPMHookPoint *HP_elemental_search_index_pre;
+struct HPMHookPoint *HP_elemental_search_index_post;
+struct HPMHookPoint *HP_elemental_summon_init_pre;
+struct HPMHookPoint *HP_elemental_summon_init_post;
+struct HPMHookPoint *HP_elemental_summon_end_timer_pre;
+struct HPMHookPoint *HP_elemental_summon_end_timer_post;
+struct HPMHookPoint *HP_elemental_ai_sub_timer_activesearch_pre;
+struct HPMHookPoint *HP_elemental_ai_sub_timer_activesearch_post;
+struct HPMHookPoint *HP_elemental_ai_sub_timer_pre;
+struct HPMHookPoint *HP_elemental_ai_sub_timer_post;
+struct HPMHookPoint *HP_elemental_ai_sub_foreachclient_pre;
+struct HPMHookPoint *HP_elemental_ai_sub_foreachclient_post;
+struct HPMHookPoint *HP_elemental_ai_timer_pre;
+struct HPMHookPoint *HP_elemental_ai_timer_post;
+struct HPMHookPoint *HP_elemental_read_db_pre;
+struct HPMHookPoint *HP_elemental_read_db_post;
+struct HPMHookPoint *HP_guild_init_pre;
+struct HPMHookPoint *HP_guild_init_post;
+struct HPMHookPoint *HP_guild_final_pre;
+struct HPMHookPoint *HP_guild_final_post;
+struct HPMHookPoint *HP_guild_skill_get_max_pre;
+struct HPMHookPoint *HP_guild_skill_get_max_post;
+struct HPMHookPoint *HP_guild_checkskill_pre;
+struct HPMHookPoint *HP_guild_checkskill_post;
+struct HPMHookPoint *HP_guild_check_skill_require_pre;
+struct HPMHookPoint *HP_guild_check_skill_require_post;
+struct HPMHookPoint *HP_guild_checkcastles_pre;
+struct HPMHookPoint *HP_guild_checkcastles_post;
+struct HPMHookPoint *HP_guild_isallied_pre;
+struct HPMHookPoint *HP_guild_isallied_post;
+struct HPMHookPoint *HP_guild_search_pre;
+struct HPMHookPoint *HP_guild_search_post;
+struct HPMHookPoint *HP_guild_searchname_pre;
+struct HPMHookPoint *HP_guild_searchname_post;
+struct HPMHookPoint *HP_guild_castle_search_pre;
+struct HPMHookPoint *HP_guild_castle_search_post;
+struct HPMHookPoint *HP_guild_mapname2gc_pre;
+struct HPMHookPoint *HP_guild_mapname2gc_post;
+struct HPMHookPoint *HP_guild_mapindex2gc_pre;
+struct HPMHookPoint *HP_guild_mapindex2gc_post;
+struct HPMHookPoint *HP_guild_getavailablesd_pre;
+struct HPMHookPoint *HP_guild_getavailablesd_post;
+struct HPMHookPoint *HP_guild_getindex_pre;
+struct HPMHookPoint *HP_guild_getindex_post;
+struct HPMHookPoint *HP_guild_getposition_pre;
+struct HPMHookPoint *HP_guild_getposition_post;
+struct HPMHookPoint *HP_guild_payexp_pre;
+struct HPMHookPoint *HP_guild_payexp_post;
+struct HPMHookPoint *HP_guild_getexp_pre;
+struct HPMHookPoint *HP_guild_getexp_post;
+struct HPMHookPoint *HP_guild_create_pre;
+struct HPMHookPoint *HP_guild_create_post;
+struct HPMHookPoint *HP_guild_created_pre;
+struct HPMHookPoint *HP_guild_created_post;
+struct HPMHookPoint *HP_guild_request_info_pre;
+struct HPMHookPoint *HP_guild_request_info_post;
+struct HPMHookPoint *HP_guild_recv_noinfo_pre;
+struct HPMHookPoint *HP_guild_recv_noinfo_post;
+struct HPMHookPoint *HP_guild_recv_info_pre;
+struct HPMHookPoint *HP_guild_recv_info_post;
+struct HPMHookPoint *HP_guild_npc_request_info_pre;
+struct HPMHookPoint *HP_guild_npc_request_info_post;
+struct HPMHookPoint *HP_guild_invite_pre;
+struct HPMHookPoint *HP_guild_invite_post;
+struct HPMHookPoint *HP_guild_reply_invite_pre;
+struct HPMHookPoint *HP_guild_reply_invite_post;
+struct HPMHookPoint *HP_guild_member_joined_pre;
+struct HPMHookPoint *HP_guild_member_joined_post;
+struct HPMHookPoint *HP_guild_member_added_pre;
+struct HPMHookPoint *HP_guild_member_added_post;
+struct HPMHookPoint *HP_guild_leave_pre;
+struct HPMHookPoint *HP_guild_leave_post;
+struct HPMHookPoint *HP_guild_member_withdraw_pre;
+struct HPMHookPoint *HP_guild_member_withdraw_post;
+struct HPMHookPoint *HP_guild_expulsion_pre;
+struct HPMHookPoint *HP_guild_expulsion_post;
+struct HPMHookPoint *HP_guild_skillup_pre;
+struct HPMHookPoint *HP_guild_skillup_post;
+struct HPMHookPoint *HP_guild_block_skill_pre;
+struct HPMHookPoint *HP_guild_block_skill_post;
+struct HPMHookPoint *HP_guild_reqalliance_pre;
+struct HPMHookPoint *HP_guild_reqalliance_post;
+struct HPMHookPoint *HP_guild_reply_reqalliance_pre;
+struct HPMHookPoint *HP_guild_reply_reqalliance_post;
+struct HPMHookPoint *HP_guild_allianceack_pre;
+struct HPMHookPoint *HP_guild_allianceack_post;
+struct HPMHookPoint *HP_guild_delalliance_pre;
+struct HPMHookPoint *HP_guild_delalliance_post;
+struct HPMHookPoint *HP_guild_opposition_pre;
+struct HPMHookPoint *HP_guild_opposition_post;
+struct HPMHookPoint *HP_guild_check_alliance_pre;
+struct HPMHookPoint *HP_guild_check_alliance_post;
+struct HPMHookPoint *HP_guild_send_memberinfoshort_pre;
+struct HPMHookPoint *HP_guild_send_memberinfoshort_post;
+struct HPMHookPoint *HP_guild_recv_memberinfoshort_pre;
+struct HPMHookPoint *HP_guild_recv_memberinfoshort_post;
+struct HPMHookPoint *HP_guild_change_memberposition_pre;
+struct HPMHookPoint *HP_guild_change_memberposition_post;
+struct HPMHookPoint *HP_guild_memberposition_changed_pre;
+struct HPMHookPoint *HP_guild_memberposition_changed_post;
+struct HPMHookPoint *HP_guild_change_position_pre;
+struct HPMHookPoint *HP_guild_change_position_post;
+struct HPMHookPoint *HP_guild_position_changed_pre;
+struct HPMHookPoint *HP_guild_position_changed_post;
+struct HPMHookPoint *HP_guild_change_notice_pre;
+struct HPMHookPoint *HP_guild_change_notice_post;
+struct HPMHookPoint *HP_guild_notice_changed_pre;
+struct HPMHookPoint *HP_guild_notice_changed_post;
+struct HPMHookPoint *HP_guild_change_emblem_pre;
+struct HPMHookPoint *HP_guild_change_emblem_post;
+struct HPMHookPoint *HP_guild_emblem_changed_pre;
+struct HPMHookPoint *HP_guild_emblem_changed_post;
+struct HPMHookPoint *HP_guild_send_message_pre;
+struct HPMHookPoint *HP_guild_send_message_post;
+struct HPMHookPoint *HP_guild_recv_message_pre;
+struct HPMHookPoint *HP_guild_recv_message_post;
+struct HPMHookPoint *HP_guild_send_dot_remove_pre;
+struct HPMHookPoint *HP_guild_send_dot_remove_post;
+struct HPMHookPoint *HP_guild_skillupack_pre;
+struct HPMHookPoint *HP_guild_skillupack_post;
+struct HPMHookPoint *HP_guild_dobreak_pre;
+struct HPMHookPoint *HP_guild_dobreak_post;
+struct HPMHookPoint *HP_guild_broken_pre;
+struct HPMHookPoint *HP_guild_broken_post;
+struct HPMHookPoint *HP_guild_gm_change_pre;
+struct HPMHookPoint *HP_guild_gm_change_post;
+struct HPMHookPoint *HP_guild_gm_changed_pre;
+struct HPMHookPoint *HP_guild_gm_changed_post;
+struct HPMHookPoint *HP_guild_castle_map_init_pre;
+struct HPMHookPoint *HP_guild_castle_map_init_post;
+struct HPMHookPoint *HP_guild_castledatasave_pre;
+struct HPMHookPoint *HP_guild_castledatasave_post;
+struct HPMHookPoint *HP_guild_castledataloadack_pre;
+struct HPMHookPoint *HP_guild_castledataloadack_post;
+struct HPMHookPoint *HP_guild_castle_reconnect_pre;
+struct HPMHookPoint *HP_guild_castle_reconnect_post;
+struct HPMHookPoint *HP_guild_agit_start_pre;
+struct HPMHookPoint *HP_guild_agit_start_post;
+struct HPMHookPoint *HP_guild_agit_end_pre;
+struct HPMHookPoint *HP_guild_agit_end_post;
+struct HPMHookPoint *HP_guild_agit2_start_pre;
+struct HPMHookPoint *HP_guild_agit2_start_post;
+struct HPMHookPoint *HP_guild_agit2_end_pre;
+struct HPMHookPoint *HP_guild_agit2_end_post;
+struct HPMHookPoint *HP_guild_flag_add_pre;
+struct HPMHookPoint *HP_guild_flag_add_post;
+struct HPMHookPoint *HP_guild_flag_remove_pre;
+struct HPMHookPoint *HP_guild_flag_remove_post;
+struct HPMHookPoint *HP_guild_flags_clear_pre;
+struct HPMHookPoint *HP_guild_flags_clear_post;
+struct HPMHookPoint *HP_guild_aura_refresh_pre;
+struct HPMHookPoint *HP_guild_aura_refresh_post;
+struct HPMHookPoint *HP_guild_payexp_timer_pre;
+struct HPMHookPoint *HP_guild_payexp_timer_post;
+struct HPMHookPoint *HP_guild_sd_check_pre;
+struct HPMHookPoint *HP_guild_sd_check_post;
+struct HPMHookPoint *HP_guild_read_guildskill_tree_db_pre;
+struct HPMHookPoint *HP_guild_read_guildskill_tree_db_post;
+struct HPMHookPoint *HP_guild_read_castledb_pre;
+struct HPMHookPoint *HP_guild_read_castledb_post;
+struct HPMHookPoint *HP_guild_payexp_timer_sub_pre;
+struct HPMHookPoint *HP_guild_payexp_timer_sub_post;
+struct HPMHookPoint *HP_guild_send_xy_timer_sub_pre;
+struct HPMHookPoint *HP_guild_send_xy_timer_sub_post;
+struct HPMHookPoint *HP_guild_send_xy_timer_pre;
+struct HPMHookPoint *HP_guild_send_xy_timer_post;
+struct HPMHookPoint *HP_guild_create_expcache_pre;
+struct HPMHookPoint *HP_guild_create_expcache_post;
+struct HPMHookPoint *HP_guild_eventlist_db_final_pre;
+struct HPMHookPoint *HP_guild_eventlist_db_final_post;
+struct HPMHookPoint *HP_guild_expcache_db_final_pre;
+struct HPMHookPoint *HP_guild_expcache_db_final_post;
+struct HPMHookPoint *HP_guild_castle_db_final_pre;
+struct HPMHookPoint *HP_guild_castle_db_final_post;
+struct HPMHookPoint *HP_guild_broken_sub_pre;
+struct HPMHookPoint *HP_guild_broken_sub_post;
+struct HPMHookPoint *HP_guild_castle_broken_sub_pre;
+struct HPMHookPoint *HP_guild_castle_broken_sub_post;
+struct HPMHookPoint *HP_guild_makemember_pre;
+struct HPMHookPoint *HP_guild_makemember_post;
+struct HPMHookPoint *HP_guild_check_member_pre;
+struct HPMHookPoint *HP_guild_check_member_post;
+struct HPMHookPoint *HP_guild_get_alliance_count_pre;
+struct HPMHookPoint *HP_guild_get_alliance_count_post;
+struct HPMHookPoint *HP_guild_castle_reconnect_sub_pre;
+struct HPMHookPoint *HP_guild_castle_reconnect_sub_post;
+struct HPMHookPoint *HP_gstorage_id2storage_pre;
+struct HPMHookPoint *HP_gstorage_id2storage_post;
+struct HPMHookPoint *HP_gstorage_id2storage2_pre;
+struct HPMHookPoint *HP_gstorage_id2storage2_post;
+struct HPMHookPoint *HP_gstorage_init_pre;
+struct HPMHookPoint *HP_gstorage_init_post;
+struct HPMHookPoint *HP_gstorage_final_pre;
+struct HPMHookPoint *HP_gstorage_final_post;
+struct HPMHookPoint *HP_gstorage_delete_pre;
+struct HPMHookPoint *HP_gstorage_delete_post;
+struct HPMHookPoint *HP_gstorage_open_pre;
+struct HPMHookPoint *HP_gstorage_open_post;
+struct HPMHookPoint *HP_gstorage_additem_pre;
+struct HPMHookPoint *HP_gstorage_additem_post;
+struct HPMHookPoint *HP_gstorage_delitem_pre;
+struct HPMHookPoint *HP_gstorage_delitem_post;
+struct HPMHookPoint *HP_gstorage_add_pre;
+struct HPMHookPoint *HP_gstorage_add_post;
+struct HPMHookPoint *HP_gstorage_get_pre;
+struct HPMHookPoint *HP_gstorage_get_post;
+struct HPMHookPoint *HP_gstorage_addfromcart_pre;
+struct HPMHookPoint *HP_gstorage_addfromcart_post;
+struct HPMHookPoint *HP_gstorage_gettocart_pre;
+struct HPMHookPoint *HP_gstorage_gettocart_post;
+struct HPMHookPoint *HP_gstorage_close_pre;
+struct HPMHookPoint *HP_gstorage_close_post;
+struct HPMHookPoint *HP_gstorage_pc_quit_pre;
+struct HPMHookPoint *HP_gstorage_pc_quit_post;
+struct HPMHookPoint *HP_gstorage_save_pre;
+struct HPMHookPoint *HP_gstorage_save_post;
+struct HPMHookPoint *HP_gstorage_saved_pre;
+struct HPMHookPoint *HP_gstorage_saved_post;
+struct HPMHookPoint *HP_gstorage_create_pre;
+struct HPMHookPoint *HP_gstorage_create_post;
+struct HPMHookPoint *HP_homun_init_pre;
+struct HPMHookPoint *HP_homun_init_post;
+struct HPMHookPoint *HP_homun_final_pre;
+struct HPMHookPoint *HP_homun_final_post;
+struct HPMHookPoint *HP_homun_reload_pre;
+struct HPMHookPoint *HP_homun_reload_post;
+struct HPMHookPoint *HP_homun_reload_skill_pre;
+struct HPMHookPoint *HP_homun_reload_skill_post;
+struct HPMHookPoint *HP_homun_get_viewdata_pre;
+struct HPMHookPoint *HP_homun_get_viewdata_post;
+struct HPMHookPoint *HP_homun_class2type_pre;
+struct HPMHookPoint *HP_homun_class2type_post;
+struct HPMHookPoint *HP_homun_damaged_pre;
+struct HPMHookPoint *HP_homun_damaged_post;
+struct HPMHookPoint *HP_homun_dead_pre;
+struct HPMHookPoint *HP_homun_dead_post;
+struct HPMHookPoint *HP_homun_vaporize_pre;
+struct HPMHookPoint *HP_homun_vaporize_post;
+struct HPMHookPoint *HP_homun_delete_pre;
+struct HPMHookPoint *HP_homun_delete_post;
+struct HPMHookPoint *HP_homun_checkskill_pre;
+struct HPMHookPoint *HP_homun_checkskill_post;
+struct HPMHookPoint *HP_homun_calc_skilltree_pre;
+struct HPMHookPoint *HP_homun_calc_skilltree_post;
+struct HPMHookPoint *HP_homun_skill_tree_get_max_pre;
+struct HPMHookPoint *HP_homun_skill_tree_get_max_post;
+struct HPMHookPoint *HP_homun_skillup_pre;
+struct HPMHookPoint *HP_homun_skillup_post;
+struct HPMHookPoint *HP_homun_levelup_pre;
+struct HPMHookPoint *HP_homun_levelup_post;
+struct HPMHookPoint *HP_homun_change_class_pre;
+struct HPMHookPoint *HP_homun_change_class_post;
+struct HPMHookPoint *HP_homun_evolve_pre;
+struct HPMHookPoint *HP_homun_evolve_post;
+struct HPMHookPoint *HP_homun_mutate_pre;
+struct HPMHookPoint *HP_homun_mutate_post;
+struct HPMHookPoint *HP_homun_gainexp_pre;
+struct HPMHookPoint *HP_homun_gainexp_post;
+struct HPMHookPoint *HP_homun_add_intimacy_pre;
+struct HPMHookPoint *HP_homun_add_intimacy_post;
+struct HPMHookPoint *HP_homun_consume_intimacy_pre;
+struct HPMHookPoint *HP_homun_consume_intimacy_post;
+struct HPMHookPoint *HP_homun_healed_pre;
+struct HPMHookPoint *HP_homun_healed_post;
+struct HPMHookPoint *HP_homun_save_pre;
+struct HPMHookPoint *HP_homun_save_post;
+struct HPMHookPoint *HP_homun_menu_pre;
+struct HPMHookPoint *HP_homun_menu_post;
+struct HPMHookPoint *HP_homun_feed_pre;
+struct HPMHookPoint *HP_homun_feed_post;
+struct HPMHookPoint *HP_homun_hunger_timer_pre;
+struct HPMHookPoint *HP_homun_hunger_timer_post;
+struct HPMHookPoint *HP_homun_hunger_timer_delete_pre;
+struct HPMHookPoint *HP_homun_hunger_timer_delete_post;
+struct HPMHookPoint *HP_homun_change_name_pre;
+struct HPMHookPoint *HP_homun_change_name_post;
+struct HPMHookPoint *HP_homun_change_name_ack_pre;
+struct HPMHookPoint *HP_homun_change_name_ack_post;
+struct HPMHookPoint *HP_homun_db_search_pre;
+struct HPMHookPoint *HP_homun_db_search_post;
+struct HPMHookPoint *HP_homun_create_pre;
+struct HPMHookPoint *HP_homun_create_post;
+struct HPMHookPoint *HP_homun_init_timers_pre;
+struct HPMHookPoint *HP_homun_init_timers_post;
+struct HPMHookPoint *HP_homun_call_pre;
+struct HPMHookPoint *HP_homun_call_post;
+struct HPMHookPoint *HP_homun_recv_data_pre;
+struct HPMHookPoint *HP_homun_recv_data_post;
+struct HPMHookPoint *HP_homun_creation_request_pre;
+struct HPMHookPoint *HP_homun_creation_request_post;
+struct HPMHookPoint *HP_homun_ressurect_pre;
+struct HPMHookPoint *HP_homun_ressurect_post;
+struct HPMHookPoint *HP_homun_revive_pre;
+struct HPMHookPoint *HP_homun_revive_post;
+struct HPMHookPoint *HP_homun_stat_reset_pre;
+struct HPMHookPoint *HP_homun_stat_reset_post;
+struct HPMHookPoint *HP_homun_shuffle_pre;
+struct HPMHookPoint *HP_homun_shuffle_post;
+struct HPMHookPoint *HP_homun_read_db_sub_pre;
+struct HPMHookPoint *HP_homun_read_db_sub_post;
+struct HPMHookPoint *HP_homun_read_db_pre;
+struct HPMHookPoint *HP_homun_read_db_post;
+struct HPMHookPoint *HP_homun_read_skill_db_sub_pre;
+struct HPMHookPoint *HP_homun_read_skill_db_sub_post;
+struct HPMHookPoint *HP_homun_skill_db_read_pre;
+struct HPMHookPoint *HP_homun_skill_db_read_post;
+struct HPMHookPoint *HP_homun_exp_db_read_pre;
+struct HPMHookPoint *HP_homun_exp_db_read_post;
+struct HPMHookPoint *HP_homun_addspiritball_pre;
+struct HPMHookPoint *HP_homun_addspiritball_post;
+struct HPMHookPoint *HP_homun_delspiritball_pre;
+struct HPMHookPoint *HP_homun_delspiritball_post;
+struct HPMHookPoint *HP_instance_init_pre;
+struct HPMHookPoint *HP_instance_init_post;
+struct HPMHookPoint *HP_instance_final_pre;
+struct HPMHookPoint *HP_instance_final_post;
+struct HPMHookPoint *HP_instance_create_pre;
+struct HPMHookPoint *HP_instance_create_post;
+struct HPMHookPoint *HP_instance_add_map_pre;
+struct HPMHookPoint *HP_instance_add_map_post;
+struct HPMHookPoint *HP_instance_del_map_pre;
+struct HPMHookPoint *HP_instance_del_map_post;
+struct HPMHookPoint *HP_instance_map2imap_pre;
+struct HPMHookPoint *HP_instance_map2imap_post;
+struct HPMHookPoint *HP_instance_mapid2imapid_pre;
+struct HPMHookPoint *HP_instance_mapid2imapid_post;
+struct HPMHookPoint *HP_instance_destroy_pre;
+struct HPMHookPoint *HP_instance_destroy_post;
+struct HPMHookPoint *HP_instance_start_pre;
+struct HPMHookPoint *HP_instance_start_post;
+struct HPMHookPoint *HP_instance_check_idle_pre;
+struct HPMHookPoint *HP_instance_check_idle_post;
+struct HPMHookPoint *HP_instance_check_kick_pre;
+struct HPMHookPoint *HP_instance_check_kick_post;
+struct HPMHookPoint *HP_instance_set_timeout_pre;
+struct HPMHookPoint *HP_instance_set_timeout_post;
+struct HPMHookPoint *HP_instance_valid_pre;
+struct HPMHookPoint *HP_instance_valid_post;
+struct HPMHookPoint *HP_instance_destroy_timer_pre;
+struct HPMHookPoint *HP_instance_destroy_timer_post;
+struct HPMHookPoint *HP_intif_parse_pre;
+struct HPMHookPoint *HP_intif_parse_post;
+struct HPMHookPoint *HP_intif_create_pet_pre;
+struct HPMHookPoint *HP_intif_create_pet_post;
+struct HPMHookPoint *HP_intif_broadcast_pre;
+struct HPMHookPoint *HP_intif_broadcast_post;
+struct HPMHookPoint *HP_intif_broadcast2_pre;
+struct HPMHookPoint *HP_intif_broadcast2_post;
+struct HPMHookPoint *HP_intif_main_message_pre;
+struct HPMHookPoint *HP_intif_main_message_post;
+struct HPMHookPoint *HP_intif_wis_message_pre;
+struct HPMHookPoint *HP_intif_wis_message_post;
+struct HPMHookPoint *HP_intif_wis_message_to_gm_pre;
+struct HPMHookPoint *HP_intif_wis_message_to_gm_post;
+struct HPMHookPoint *HP_intif_saveregistry_pre;
+struct HPMHookPoint *HP_intif_saveregistry_post;
+struct HPMHookPoint *HP_intif_request_registry_pre;
+struct HPMHookPoint *HP_intif_request_registry_post;
+struct HPMHookPoint *HP_intif_request_guild_storage_pre;
+struct HPMHookPoint *HP_intif_request_guild_storage_post;
+struct HPMHookPoint *HP_intif_send_guild_storage_pre;
+struct HPMHookPoint *HP_intif_send_guild_storage_post;
+struct HPMHookPoint *HP_intif_create_party_pre;
+struct HPMHookPoint *HP_intif_create_party_post;
+struct HPMHookPoint *HP_intif_request_partyinfo_pre;
+struct HPMHookPoint *HP_intif_request_partyinfo_post;
+struct HPMHookPoint *HP_intif_party_addmember_pre;
+struct HPMHookPoint *HP_intif_party_addmember_post;
+struct HPMHookPoint *HP_intif_party_changeoption_pre;
+struct HPMHookPoint *HP_intif_party_changeoption_post;
+struct HPMHookPoint *HP_intif_party_leave_pre;
+struct HPMHookPoint *HP_intif_party_leave_post;
+struct HPMHookPoint *HP_intif_party_changemap_pre;
+struct HPMHookPoint *HP_intif_party_changemap_post;
+struct HPMHookPoint *HP_intif_break_party_pre;
+struct HPMHookPoint *HP_intif_break_party_post;
+struct HPMHookPoint *HP_intif_party_message_pre;
+struct HPMHookPoint *HP_intif_party_message_post;
+struct HPMHookPoint *HP_intif_party_leaderchange_pre;
+struct HPMHookPoint *HP_intif_party_leaderchange_post;
+struct HPMHookPoint *HP_intif_guild_create_pre;
+struct HPMHookPoint *HP_intif_guild_create_post;
+struct HPMHookPoint *HP_intif_guild_request_info_pre;
+struct HPMHookPoint *HP_intif_guild_request_info_post;
+struct HPMHookPoint *HP_intif_guild_addmember_pre;
+struct HPMHookPoint *HP_intif_guild_addmember_post;
+struct HPMHookPoint *HP_intif_guild_leave_pre;
+struct HPMHookPoint *HP_intif_guild_leave_post;
+struct HPMHookPoint *HP_intif_guild_memberinfoshort_pre;
+struct HPMHookPoint *HP_intif_guild_memberinfoshort_post;
+struct HPMHookPoint *HP_intif_guild_break_pre;
+struct HPMHookPoint *HP_intif_guild_break_post;
+struct HPMHookPoint *HP_intif_guild_message_pre;
+struct HPMHookPoint *HP_intif_guild_message_post;
+struct HPMHookPoint *HP_intif_guild_change_gm_pre;
+struct HPMHookPoint *HP_intif_guild_change_gm_post;
+struct HPMHookPoint *HP_intif_guild_change_basicinfo_pre;
+struct HPMHookPoint *HP_intif_guild_change_basicinfo_post;
+struct HPMHookPoint *HP_intif_guild_change_memberinfo_pre;
+struct HPMHookPoint *HP_intif_guild_change_memberinfo_post;
+struct HPMHookPoint *HP_intif_guild_position_pre;
+struct HPMHookPoint *HP_intif_guild_position_post;
+struct HPMHookPoint *HP_intif_guild_skillup_pre;
+struct HPMHookPoint *HP_intif_guild_skillup_post;
+struct HPMHookPoint *HP_intif_guild_alliance_pre;
+struct HPMHookPoint *HP_intif_guild_alliance_post;
+struct HPMHookPoint *HP_intif_guild_notice_pre;
+struct HPMHookPoint *HP_intif_guild_notice_post;
+struct HPMHookPoint *HP_intif_guild_emblem_pre;
+struct HPMHookPoint *HP_intif_guild_emblem_post;
+struct HPMHookPoint *HP_intif_guild_castle_dataload_pre;
+struct HPMHookPoint *HP_intif_guild_castle_dataload_post;
+struct HPMHookPoint *HP_intif_guild_castle_datasave_pre;
+struct HPMHookPoint *HP_intif_guild_castle_datasave_post;
+struct HPMHookPoint *HP_intif_request_petdata_pre;
+struct HPMHookPoint *HP_intif_request_petdata_post;
+struct HPMHookPoint *HP_intif_save_petdata_pre;
+struct HPMHookPoint *HP_intif_save_petdata_post;
+struct HPMHookPoint *HP_intif_delete_petdata_pre;
+struct HPMHookPoint *HP_intif_delete_petdata_post;
+struct HPMHookPoint *HP_intif_rename_pre;
+struct HPMHookPoint *HP_intif_rename_post;
+struct HPMHookPoint *HP_intif_homunculus_create_pre;
+struct HPMHookPoint *HP_intif_homunculus_create_post;
+struct HPMHookPoint *HP_intif_homunculus_requestload_pre;
+struct HPMHookPoint *HP_intif_homunculus_requestload_post;
+struct HPMHookPoint *HP_intif_homunculus_requestsave_pre;
+struct HPMHookPoint *HP_intif_homunculus_requestsave_post;
+struct HPMHookPoint *HP_intif_homunculus_requestdelete_pre;
+struct HPMHookPoint *HP_intif_homunculus_requestdelete_post;
+struct HPMHookPoint *HP_intif_request_questlog_pre;
+struct HPMHookPoint *HP_intif_request_questlog_post;
+struct HPMHookPoint *HP_intif_quest_save_pre;
+struct HPMHookPoint *HP_intif_quest_save_post;
+struct HPMHookPoint *HP_intif_mercenary_create_pre;
+struct HPMHookPoint *HP_intif_mercenary_create_post;
+struct HPMHookPoint *HP_intif_mercenary_request_pre;
+struct HPMHookPoint *HP_intif_mercenary_request_post;
+struct HPMHookPoint *HP_intif_mercenary_delete_pre;
+struct HPMHookPoint *HP_intif_mercenary_delete_post;
+struct HPMHookPoint *HP_intif_mercenary_save_pre;
+struct HPMHookPoint *HP_intif_mercenary_save_post;
+struct HPMHookPoint *HP_intif_Mail_requestinbox_pre;
+struct HPMHookPoint *HP_intif_Mail_requestinbox_post;
+struct HPMHookPoint *HP_intif_Mail_read_pre;
+struct HPMHookPoint *HP_intif_Mail_read_post;
+struct HPMHookPoint *HP_intif_Mail_getattach_pre;
+struct HPMHookPoint *HP_intif_Mail_getattach_post;
+struct HPMHookPoint *HP_intif_Mail_delete_pre;
+struct HPMHookPoint *HP_intif_Mail_delete_post;
+struct HPMHookPoint *HP_intif_Mail_return_pre;
+struct HPMHookPoint *HP_intif_Mail_return_post;
+struct HPMHookPoint *HP_intif_Mail_send_pre;
+struct HPMHookPoint *HP_intif_Mail_send_post;
+struct HPMHookPoint *HP_intif_Auction_requestlist_pre;
+struct HPMHookPoint *HP_intif_Auction_requestlist_post;
+struct HPMHookPoint *HP_intif_Auction_register_pre;
+struct HPMHookPoint *HP_intif_Auction_register_post;
+struct HPMHookPoint *HP_intif_Auction_cancel_pre;
+struct HPMHookPoint *HP_intif_Auction_cancel_post;
+struct HPMHookPoint *HP_intif_Auction_close_pre;
+struct HPMHookPoint *HP_intif_Auction_close_post;
+struct HPMHookPoint *HP_intif_Auction_bid_pre;
+struct HPMHookPoint *HP_intif_Auction_bid_post;
+struct HPMHookPoint *HP_intif_elemental_create_pre;
+struct HPMHookPoint *HP_intif_elemental_create_post;
+struct HPMHookPoint *HP_intif_elemental_request_pre;
+struct HPMHookPoint *HP_intif_elemental_request_post;
+struct HPMHookPoint *HP_intif_elemental_delete_pre;
+struct HPMHookPoint *HP_intif_elemental_delete_post;
+struct HPMHookPoint *HP_intif_elemental_save_pre;
+struct HPMHookPoint *HP_intif_elemental_save_post;
+struct HPMHookPoint *HP_intif_request_accinfo_pre;
+struct HPMHookPoint *HP_intif_request_accinfo_post;
+struct HPMHookPoint *HP_intif_CheckForCharServer_pre;
+struct HPMHookPoint *HP_intif_CheckForCharServer_post;
+struct HPMHookPoint *HP_intif_pWisMessage_pre;
+struct HPMHookPoint *HP_intif_pWisMessage_post;
+struct HPMHookPoint *HP_intif_pWisEnd_pre;
+struct HPMHookPoint *HP_intif_pWisEnd_post;
+struct HPMHookPoint *HP_intif_pWisToGM_sub_pre;
+struct HPMHookPoint *HP_intif_pWisToGM_sub_post;
+struct HPMHookPoint *HP_intif_pWisToGM_pre;
+struct HPMHookPoint *HP_intif_pWisToGM_post;
+struct HPMHookPoint *HP_intif_pRegisters_pre;
+struct HPMHookPoint *HP_intif_pRegisters_post;
+struct HPMHookPoint *HP_intif_pChangeNameOk_pre;
+struct HPMHookPoint *HP_intif_pChangeNameOk_post;
+struct HPMHookPoint *HP_intif_pMessageToFD_pre;
+struct HPMHookPoint *HP_intif_pMessageToFD_post;
+struct HPMHookPoint *HP_intif_pLoadGuildStorage_pre;
+struct HPMHookPoint *HP_intif_pLoadGuildStorage_post;
+struct HPMHookPoint *HP_intif_pSaveGuildStorage_pre;
+struct HPMHookPoint *HP_intif_pSaveGuildStorage_post;
+struct HPMHookPoint *HP_intif_pPartyCreated_pre;
+struct HPMHookPoint *HP_intif_pPartyCreated_post;
+struct HPMHookPoint *HP_intif_pPartyInfo_pre;
+struct HPMHookPoint *HP_intif_pPartyInfo_post;
+struct HPMHookPoint *HP_intif_pPartyMemberAdded_pre;
+struct HPMHookPoint *HP_intif_pPartyMemberAdded_post;
+struct HPMHookPoint *HP_intif_pPartyOptionChanged_pre;
+struct HPMHookPoint *HP_intif_pPartyOptionChanged_post;
+struct HPMHookPoint *HP_intif_pPartyMemberWithdraw_pre;
+struct HPMHookPoint *HP_intif_pPartyMemberWithdraw_post;
+struct HPMHookPoint *HP_intif_pPartyMove_pre;
+struct HPMHookPoint *HP_intif_pPartyMove_post;
+struct HPMHookPoint *HP_intif_pPartyBroken_pre;
+struct HPMHookPoint *HP_intif_pPartyBroken_post;
+struct HPMHookPoint *HP_intif_pPartyMessage_pre;
+struct HPMHookPoint *HP_intif_pPartyMessage_post;
+struct HPMHookPoint *HP_intif_pGuildCreated_pre;
+struct HPMHookPoint *HP_intif_pGuildCreated_post;
+struct HPMHookPoint *HP_intif_pGuildInfo_pre;
+struct HPMHookPoint *HP_intif_pGuildInfo_post;
+struct HPMHookPoint *HP_intif_pGuildMemberAdded_pre;
+struct HPMHookPoint *HP_intif_pGuildMemberAdded_post;
+struct HPMHookPoint *HP_intif_pGuildMemberWithdraw_pre;
+struct HPMHookPoint *HP_intif_pGuildMemberWithdraw_post;
+struct HPMHookPoint *HP_intif_pGuildMemberInfoShort_pre;
+struct HPMHookPoint *HP_intif_pGuildMemberInfoShort_post;
+struct HPMHookPoint *HP_intif_pGuildBroken_pre;
+struct HPMHookPoint *HP_intif_pGuildBroken_post;
+struct HPMHookPoint *HP_intif_pGuildMessage_pre;
+struct HPMHookPoint *HP_intif_pGuildMessage_post;
+struct HPMHookPoint *HP_intif_pGuildBasicInfoChanged_pre;
+struct HPMHookPoint *HP_intif_pGuildBasicInfoChanged_post;
+struct HPMHookPoint *HP_intif_pGuildMemberInfoChanged_pre;
+struct HPMHookPoint *HP_intif_pGuildMemberInfoChanged_post;
+struct HPMHookPoint *HP_intif_pGuildPosition_pre;
+struct HPMHookPoint *HP_intif_pGuildPosition_post;
+struct HPMHookPoint *HP_intif_pGuildSkillUp_pre;
+struct HPMHookPoint *HP_intif_pGuildSkillUp_post;
+struct HPMHookPoint *HP_intif_pGuildAlliance_pre;
+struct HPMHookPoint *HP_intif_pGuildAlliance_post;
+struct HPMHookPoint *HP_intif_pGuildNotice_pre;
+struct HPMHookPoint *HP_intif_pGuildNotice_post;
+struct HPMHookPoint *HP_intif_pGuildEmblem_pre;
+struct HPMHookPoint *HP_intif_pGuildEmblem_post;
+struct HPMHookPoint *HP_intif_pGuildCastleDataLoad_pre;
+struct HPMHookPoint *HP_intif_pGuildCastleDataLoad_post;
+struct HPMHookPoint *HP_intif_pGuildMasterChanged_pre;
+struct HPMHookPoint *HP_intif_pGuildMasterChanged_post;
+struct HPMHookPoint *HP_intif_pQuestLog_pre;
+struct HPMHookPoint *HP_intif_pQuestLog_post;
+struct HPMHookPoint *HP_intif_pQuestSave_pre;
+struct HPMHookPoint *HP_intif_pQuestSave_post;
+struct HPMHookPoint *HP_intif_pMailInboxReceived_pre;
+struct HPMHookPoint *HP_intif_pMailInboxReceived_post;
+struct HPMHookPoint *HP_intif_pMailNew_pre;
+struct HPMHookPoint *HP_intif_pMailNew_post;
+struct HPMHookPoint *HP_intif_pMailGetAttach_pre;
+struct HPMHookPoint *HP_intif_pMailGetAttach_post;
+struct HPMHookPoint *HP_intif_pMailDelete_pre;
+struct HPMHookPoint *HP_intif_pMailDelete_post;
+struct HPMHookPoint *HP_intif_pMailReturn_pre;
+struct HPMHookPoint *HP_intif_pMailReturn_post;
+struct HPMHookPoint *HP_intif_pMailSend_pre;
+struct HPMHookPoint *HP_intif_pMailSend_post;
+struct HPMHookPoint *HP_intif_pAuctionResults_pre;
+struct HPMHookPoint *HP_intif_pAuctionResults_post;
+struct HPMHookPoint *HP_intif_pAuctionRegister_pre;
+struct HPMHookPoint *HP_intif_pAuctionRegister_post;
+struct HPMHookPoint *HP_intif_pAuctionCancel_pre;
+struct HPMHookPoint *HP_intif_pAuctionCancel_post;
+struct HPMHookPoint *HP_intif_pAuctionClose_pre;
+struct HPMHookPoint *HP_intif_pAuctionClose_post;
+struct HPMHookPoint *HP_intif_pAuctionMessage_pre;
+struct HPMHookPoint *HP_intif_pAuctionMessage_post;
+struct HPMHookPoint *HP_intif_pAuctionBid_pre;
+struct HPMHookPoint *HP_intif_pAuctionBid_post;
+struct HPMHookPoint *HP_intif_pMercenaryReceived_pre;
+struct HPMHookPoint *HP_intif_pMercenaryReceived_post;
+struct HPMHookPoint *HP_intif_pMercenaryDeleted_pre;
+struct HPMHookPoint *HP_intif_pMercenaryDeleted_post;
+struct HPMHookPoint *HP_intif_pMercenarySaved_pre;
+struct HPMHookPoint *HP_intif_pMercenarySaved_post;
+struct HPMHookPoint *HP_intif_pElementalReceived_pre;
+struct HPMHookPoint *HP_intif_pElementalReceived_post;
+struct HPMHookPoint *HP_intif_pElementalDeleted_pre;
+struct HPMHookPoint *HP_intif_pElementalDeleted_post;
+struct HPMHookPoint *HP_intif_pElementalSaved_pre;
+struct HPMHookPoint *HP_intif_pElementalSaved_post;
+struct HPMHookPoint *HP_intif_pCreatePet_pre;
+struct HPMHookPoint *HP_intif_pCreatePet_post;
+struct HPMHookPoint *HP_intif_pRecvPetData_pre;
+struct HPMHookPoint *HP_intif_pRecvPetData_post;
+struct HPMHookPoint *HP_intif_pSavePetOk_pre;
+struct HPMHookPoint *HP_intif_pSavePetOk_post;
+struct HPMHookPoint *HP_intif_pDeletePetOk_pre;
+struct HPMHookPoint *HP_intif_pDeletePetOk_post;
+struct HPMHookPoint *HP_intif_pCreateHomunculus_pre;
+struct HPMHookPoint *HP_intif_pCreateHomunculus_post;
+struct HPMHookPoint *HP_intif_pRecvHomunculusData_pre;
+struct HPMHookPoint *HP_intif_pRecvHomunculusData_post;
+struct HPMHookPoint *HP_intif_pSaveHomunculusOk_pre;
+struct HPMHookPoint *HP_intif_pSaveHomunculusOk_post;
+struct HPMHookPoint *HP_intif_pDeleteHomunculusOk_pre;
+struct HPMHookPoint *HP_intif_pDeleteHomunculusOk_post;
+struct HPMHookPoint *HP_ircbot_init_pre;
+struct HPMHookPoint *HP_ircbot_init_post;
+struct HPMHookPoint *HP_ircbot_final_pre;
+struct HPMHookPoint *HP_ircbot_final_post;
+struct HPMHookPoint *HP_ircbot_parse_pre;
+struct HPMHookPoint *HP_ircbot_parse_post;
+struct HPMHookPoint *HP_ircbot_parse_sub_pre;
+struct HPMHookPoint *HP_ircbot_parse_sub_post;
+struct HPMHookPoint *HP_ircbot_parse_source_pre;
+struct HPMHookPoint *HP_ircbot_parse_source_post;
+struct HPMHookPoint *HP_ircbot_func_search_pre;
+struct HPMHookPoint *HP_ircbot_func_search_post;
+struct HPMHookPoint *HP_ircbot_connect_timer_pre;
+struct HPMHookPoint *HP_ircbot_connect_timer_post;
+struct HPMHookPoint *HP_ircbot_identify_timer_pre;
+struct HPMHookPoint *HP_ircbot_identify_timer_post;
+struct HPMHookPoint *HP_ircbot_join_timer_pre;
+struct HPMHookPoint *HP_ircbot_join_timer_post;
+struct HPMHookPoint *HP_ircbot_send_pre;
+struct HPMHookPoint *HP_ircbot_send_post;
+struct HPMHookPoint *HP_ircbot_relay_pre;
+struct HPMHookPoint *HP_ircbot_relay_post;
+struct HPMHookPoint *HP_ircbot_pong_pre;
+struct HPMHookPoint *HP_ircbot_pong_post;
+struct HPMHookPoint *HP_ircbot_privmsg_pre;
+struct HPMHookPoint *HP_ircbot_privmsg_post;
+struct HPMHookPoint *HP_ircbot_userjoin_pre;
+struct HPMHookPoint *HP_ircbot_userjoin_post;
+struct HPMHookPoint *HP_ircbot_userleave_pre;
+struct HPMHookPoint *HP_ircbot_userleave_post;
+struct HPMHookPoint *HP_ircbot_usernick_pre;
+struct HPMHookPoint *HP_ircbot_usernick_post;
+struct HPMHookPoint *HP_itemdb_init_pre;
+struct HPMHookPoint *HP_itemdb_init_post;
+struct HPMHookPoint *HP_itemdb_final_pre;
+struct HPMHookPoint *HP_itemdb_final_post;
+struct HPMHookPoint *HP_itemdb_reload_pre;
+struct HPMHookPoint *HP_itemdb_reload_post;
+struct HPMHookPoint *HP_itemdb_name_constants_pre;
+struct HPMHookPoint *HP_itemdb_name_constants_post;
+struct HPMHookPoint *HP_itemdb_force_name_constants_pre;
+struct HPMHookPoint *HP_itemdb_force_name_constants_post;
+struct HPMHookPoint *HP_itemdb_read_groups_pre;
+struct HPMHookPoint *HP_itemdb_read_groups_post;
+struct HPMHookPoint *HP_itemdb_read_chains_pre;
+struct HPMHookPoint *HP_itemdb_read_chains_post;
+struct HPMHookPoint *HP_itemdb_read_packages_pre;
+struct HPMHookPoint *HP_itemdb_read_packages_post;
+struct HPMHookPoint *HP_itemdb_write_cached_packages_pre;
+struct HPMHookPoint *HP_itemdb_write_cached_packages_post;
+struct HPMHookPoint *HP_itemdb_read_cached_packages_pre;
+struct HPMHookPoint *HP_itemdb_read_cached_packages_post;
+struct HPMHookPoint *HP_itemdb_name2id_pre;
+struct HPMHookPoint *HP_itemdb_name2id_post;
+struct HPMHookPoint *HP_itemdb_search_name_pre;
+struct HPMHookPoint *HP_itemdb_search_name_post;
+struct HPMHookPoint *HP_itemdb_search_name_array_pre;
+struct HPMHookPoint *HP_itemdb_search_name_array_post;
+struct HPMHookPoint *HP_itemdb_load_pre;
+struct HPMHookPoint *HP_itemdb_load_post;
+struct HPMHookPoint *HP_itemdb_search_pre;
+struct HPMHookPoint *HP_itemdb_search_post;
+struct HPMHookPoint *HP_itemdb_parse_dbrow_pre;
+struct HPMHookPoint *HP_itemdb_parse_dbrow_post;
+struct HPMHookPoint *HP_itemdb_exists_pre;
+struct HPMHookPoint *HP_itemdb_exists_post;
+struct HPMHookPoint *HP_itemdb_in_group_pre;
+struct HPMHookPoint *HP_itemdb_in_group_post;
+struct HPMHookPoint *HP_itemdb_group_item_pre;
+struct HPMHookPoint *HP_itemdb_group_item_post;
+struct HPMHookPoint *HP_itemdb_chain_item_pre;
+struct HPMHookPoint *HP_itemdb_chain_item_post;
+struct HPMHookPoint *HP_itemdb_package_item_pre;
+struct HPMHookPoint *HP_itemdb_package_item_post;
+struct HPMHookPoint *HP_itemdb_searchname_sub_pre;
+struct HPMHookPoint *HP_itemdb_searchname_sub_post;
+struct HPMHookPoint *HP_itemdb_searchname_array_sub_pre;
+struct HPMHookPoint *HP_itemdb_searchname_array_sub_post;
+struct HPMHookPoint *HP_itemdb_searchrandomid_pre;
+struct HPMHookPoint *HP_itemdb_searchrandomid_post;
+struct HPMHookPoint *HP_itemdb_typename_pre;
+struct HPMHookPoint *HP_itemdb_typename_post;
+struct HPMHookPoint *HP_itemdb_jobid2mapid_pre;
+struct HPMHookPoint *HP_itemdb_jobid2mapid_post;
+struct HPMHookPoint *HP_itemdb_create_dummy_data_pre;
+struct HPMHookPoint *HP_itemdb_create_dummy_data_post;
+struct HPMHookPoint *HP_itemdb_create_item_data_pre;
+struct HPMHookPoint *HP_itemdb_create_item_data_post;
+struct HPMHookPoint *HP_itemdb_isequip_pre;
+struct HPMHookPoint *HP_itemdb_isequip_post;
+struct HPMHookPoint *HP_itemdb_isequip2_pre;
+struct HPMHookPoint *HP_itemdb_isequip2_post;
+struct HPMHookPoint *HP_itemdb_isstackable_pre;
+struct HPMHookPoint *HP_itemdb_isstackable_post;
+struct HPMHookPoint *HP_itemdb_isstackable2_pre;
+struct HPMHookPoint *HP_itemdb_isstackable2_post;
+struct HPMHookPoint *HP_itemdb_isdropable_sub_pre;
+struct HPMHookPoint *HP_itemdb_isdropable_sub_post;
+struct HPMHookPoint *HP_itemdb_cantrade_sub_pre;
+struct HPMHookPoint *HP_itemdb_cantrade_sub_post;
+struct HPMHookPoint *HP_itemdb_canpartnertrade_sub_pre;
+struct HPMHookPoint *HP_itemdb_canpartnertrade_sub_post;
+struct HPMHookPoint *HP_itemdb_cansell_sub_pre;
+struct HPMHookPoint *HP_itemdb_cansell_sub_post;
+struct HPMHookPoint *HP_itemdb_cancartstore_sub_pre;
+struct HPMHookPoint *HP_itemdb_cancartstore_sub_post;
+struct HPMHookPoint *HP_itemdb_canstore_sub_pre;
+struct HPMHookPoint *HP_itemdb_canstore_sub_post;
+struct HPMHookPoint *HP_itemdb_canguildstore_sub_pre;
+struct HPMHookPoint *HP_itemdb_canguildstore_sub_post;
+struct HPMHookPoint *HP_itemdb_canmail_sub_pre;
+struct HPMHookPoint *HP_itemdb_canmail_sub_post;
+struct HPMHookPoint *HP_itemdb_canauction_sub_pre;
+struct HPMHookPoint *HP_itemdb_canauction_sub_post;
+struct HPMHookPoint *HP_itemdb_isrestricted_pre;
+struct HPMHookPoint *HP_itemdb_isrestricted_post;
+struct HPMHookPoint *HP_itemdb_isidentified_pre;
+struct HPMHookPoint *HP_itemdb_isidentified_post;
+struct HPMHookPoint *HP_itemdb_isidentified2_pre;
+struct HPMHookPoint *HP_itemdb_isidentified2_post;
+struct HPMHookPoint *HP_itemdb_read_itemavail_pre;
+struct HPMHookPoint *HP_itemdb_read_itemavail_post;
+struct HPMHookPoint *HP_itemdb_read_itemtrade_pre;
+struct HPMHookPoint *HP_itemdb_read_itemtrade_post;
+struct HPMHookPoint *HP_itemdb_read_itemdelay_pre;
+struct HPMHookPoint *HP_itemdb_read_itemdelay_post;
+struct HPMHookPoint *HP_itemdb_read_stack_pre;
+struct HPMHookPoint *HP_itemdb_read_stack_post;
+struct HPMHookPoint *HP_itemdb_read_buyingstore_pre;
+struct HPMHookPoint *HP_itemdb_read_buyingstore_post;
+struct HPMHookPoint *HP_itemdb_read_nouse_pre;
+struct HPMHookPoint *HP_itemdb_read_nouse_post;
+struct HPMHookPoint *HP_itemdb_combo_split_atoi_pre;
+struct HPMHookPoint *HP_itemdb_combo_split_atoi_post;
+struct HPMHookPoint *HP_itemdb_read_combos_pre;
+struct HPMHookPoint *HP_itemdb_read_combos_post;
+struct HPMHookPoint *HP_itemdb_gendercheck_pre;
+struct HPMHookPoint *HP_itemdb_gendercheck_post;
+struct HPMHookPoint *HP_itemdb_re_split_atoi_pre;
+struct HPMHookPoint *HP_itemdb_re_split_atoi_post;
+struct HPMHookPoint *HP_itemdb_readdb_pre;
+struct HPMHookPoint *HP_itemdb_readdb_post;
+struct HPMHookPoint *HP_itemdb_read_sqldb_pre;
+struct HPMHookPoint *HP_itemdb_read_sqldb_post;
+struct HPMHookPoint *HP_itemdb_unique_id_pre;
+struct HPMHookPoint *HP_itemdb_unique_id_post;
+struct HPMHookPoint *HP_itemdb_uid_load_pre;
+struct HPMHookPoint *HP_itemdb_uid_load_post;
+struct HPMHookPoint *HP_itemdb_read_pre;
+struct HPMHookPoint *HP_itemdb_read_post;
+struct HPMHookPoint *HP_itemdb_destroy_item_data_pre;
+struct HPMHookPoint *HP_itemdb_destroy_item_data_post;
+struct HPMHookPoint *HP_itemdb_final_sub_pre;
+struct HPMHookPoint *HP_itemdb_final_sub_post;
+struct HPMHookPoint *HP_logs_pick_pc_pre;
+struct HPMHookPoint *HP_logs_pick_pc_post;
+struct HPMHookPoint *HP_logs_pick_mob_pre;
+struct HPMHookPoint *HP_logs_pick_mob_post;
+struct HPMHookPoint *HP_logs_zeny_pre;
+struct HPMHookPoint *HP_logs_zeny_post;
+struct HPMHookPoint *HP_logs_npc_pre;
+struct HPMHookPoint *HP_logs_npc_post;
+struct HPMHookPoint *HP_logs_chat_pre;
+struct HPMHookPoint *HP_logs_chat_post;
+struct HPMHookPoint *HP_logs_atcommand_pre;
+struct HPMHookPoint *HP_logs_atcommand_post;
+struct HPMHookPoint *HP_logs_branch_pre;
+struct HPMHookPoint *HP_logs_branch_post;
+struct HPMHookPoint *HP_logs_mvpdrop_pre;
+struct HPMHookPoint *HP_logs_mvpdrop_post;
+struct HPMHookPoint *HP_logs_pick_sub_pre;
+struct HPMHookPoint *HP_logs_pick_sub_post;
+struct HPMHookPoint *HP_logs_zeny_sub_pre;
+struct HPMHookPoint *HP_logs_zeny_sub_post;
+struct HPMHookPoint *HP_logs_npc_sub_pre;
+struct HPMHookPoint *HP_logs_npc_sub_post;
+struct HPMHookPoint *HP_logs_chat_sub_pre;
+struct HPMHookPoint *HP_logs_chat_sub_post;
+struct HPMHookPoint *HP_logs_atcommand_sub_pre;
+struct HPMHookPoint *HP_logs_atcommand_sub_post;
+struct HPMHookPoint *HP_logs_branch_sub_pre;
+struct HPMHookPoint *HP_logs_branch_sub_post;
+struct HPMHookPoint *HP_logs_mvpdrop_sub_pre;
+struct HPMHookPoint *HP_logs_mvpdrop_sub_post;
+struct HPMHookPoint *HP_logs_config_read_pre;
+struct HPMHookPoint *HP_logs_config_read_post;
+struct HPMHookPoint *HP_logs_config_done_pre;
+struct HPMHookPoint *HP_logs_config_done_post;
+struct HPMHookPoint *HP_logs_sql_init_pre;
+struct HPMHookPoint *HP_logs_sql_init_post;
+struct HPMHookPoint *HP_logs_sql_final_pre;
+struct HPMHookPoint *HP_logs_sql_final_post;
+struct HPMHookPoint *HP_logs_picktype2char_pre;
+struct HPMHookPoint *HP_logs_picktype2char_post;
+struct HPMHookPoint *HP_logs_chattype2char_pre;
+struct HPMHookPoint *HP_logs_chattype2char_post;
+struct HPMHookPoint *HP_logs_should_log_item_pre;
+struct HPMHookPoint *HP_logs_should_log_item_post;
+struct HPMHookPoint *HP_mail_clear_pre;
+struct HPMHookPoint *HP_mail_clear_post;
+struct HPMHookPoint *HP_mail_removeitem_pre;
+struct HPMHookPoint *HP_mail_removeitem_post;
+struct HPMHookPoint *HP_mail_removezeny_pre;
+struct HPMHookPoint *HP_mail_removezeny_post;
+struct HPMHookPoint *HP_mail_setitem_pre;
+struct HPMHookPoint *HP_mail_setitem_post;
+struct HPMHookPoint *HP_mail_setattachment_pre;
+struct HPMHookPoint *HP_mail_setattachment_post;
+struct HPMHookPoint *HP_mail_getattachment_pre;
+struct HPMHookPoint *HP_mail_getattachment_post;
+struct HPMHookPoint *HP_mail_openmail_pre;
+struct HPMHookPoint *HP_mail_openmail_post;
+struct HPMHookPoint *HP_mail_deliveryfail_pre;
+struct HPMHookPoint *HP_mail_deliveryfail_post;
+struct HPMHookPoint *HP_mail_invalid_operation_pre;
+struct HPMHookPoint *HP_mail_invalid_operation_post;
+struct HPMHookPoint *HP_map_zone_init_pre;
+struct HPMHookPoint *HP_map_zone_init_post;
+struct HPMHookPoint *HP_map_zone_remove_pre;
+struct HPMHookPoint *HP_map_zone_remove_post;
+struct HPMHookPoint *HP_map_zone_apply_pre;
+struct HPMHookPoint *HP_map_zone_apply_post;
+struct HPMHookPoint *HP_map_zone_change_pre;
+struct HPMHookPoint *HP_map_zone_change_post;
+struct HPMHookPoint *HP_map_zone_change2_pre;
+struct HPMHookPoint *HP_map_zone_change2_post;
+struct HPMHookPoint *HP_map_getcell_pre;
+struct HPMHookPoint *HP_map_getcell_post;
+struct HPMHookPoint *HP_map_setgatcell_pre;
+struct HPMHookPoint *HP_map_setgatcell_post;
+struct HPMHookPoint *HP_map_cellfromcache_pre;
+struct HPMHookPoint *HP_map_cellfromcache_post;
+struct HPMHookPoint *HP_map_setusers_pre;
+struct HPMHookPoint *HP_map_setusers_post;
+struct HPMHookPoint *HP_map_getusers_pre;
+struct HPMHookPoint *HP_map_getusers_post;
+struct HPMHookPoint *HP_map_usercount_pre;
+struct HPMHookPoint *HP_map_usercount_post;
+struct HPMHookPoint *HP_map_freeblock_pre;
+struct HPMHookPoint *HP_map_freeblock_post;
+struct HPMHookPoint *HP_map_freeblock_lock_pre;
+struct HPMHookPoint *HP_map_freeblock_lock_post;
+struct HPMHookPoint *HP_map_freeblock_unlock_pre;
+struct HPMHookPoint *HP_map_freeblock_unlock_post;
+struct HPMHookPoint *HP_map_addblock_pre;
+struct HPMHookPoint *HP_map_addblock_post;
+struct HPMHookPoint *HP_map_delblock_pre;
+struct HPMHookPoint *HP_map_delblock_post;
+struct HPMHookPoint *HP_map_moveblock_pre;
+struct HPMHookPoint *HP_map_moveblock_post;
+struct HPMHookPoint *HP_map_count_oncell_pre;
+struct HPMHookPoint *HP_map_count_oncell_post;
+struct HPMHookPoint *HP_map_find_skill_unit_oncell_pre;
+struct HPMHookPoint *HP_map_find_skill_unit_oncell_post;
+struct HPMHookPoint *HP_map_get_new_object_id_pre;
+struct HPMHookPoint *HP_map_get_new_object_id_post;
+struct HPMHookPoint *HP_map_search_freecell_pre;
+struct HPMHookPoint *HP_map_search_freecell_post;
+struct HPMHookPoint *HP_map_quit_pre;
+struct HPMHookPoint *HP_map_quit_post;
+struct HPMHookPoint *HP_map_addnpc_pre;
+struct HPMHookPoint *HP_map_addnpc_post;
+struct HPMHookPoint *HP_map_clearflooritem_timer_pre;
+struct HPMHookPoint *HP_map_clearflooritem_timer_post;
+struct HPMHookPoint *HP_map_removemobs_timer_pre;
+struct HPMHookPoint *HP_map_removemobs_timer_post;
+struct HPMHookPoint *HP_map_clearflooritem_pre;
+struct HPMHookPoint *HP_map_clearflooritem_post;
+struct HPMHookPoint *HP_map_addflooritem_pre;
+struct HPMHookPoint *HP_map_addflooritem_post;
+struct HPMHookPoint *HP_map_addnickdb_pre;
+struct HPMHookPoint *HP_map_addnickdb_post;
+struct HPMHookPoint *HP_map_delnickdb_pre;
+struct HPMHookPoint *HP_map_delnickdb_post;
+struct HPMHookPoint *HP_map_reqnickdb_pre;
+struct HPMHookPoint *HP_map_reqnickdb_post;
+struct HPMHookPoint *HP_map_charid2nick_pre;
+struct HPMHookPoint *HP_map_charid2nick_post;
+struct HPMHookPoint *HP_map_charid2sd_pre;
+struct HPMHookPoint *HP_map_charid2sd_post;
+struct HPMHookPoint *HP_map_vforeachpc_pre;
+struct HPMHookPoint *HP_map_vforeachpc_post;
+struct HPMHookPoint *HP_map_vforeachmob_pre;
+struct HPMHookPoint *HP_map_vforeachmob_post;
+struct HPMHookPoint *HP_map_vforeachnpc_pre;
+struct HPMHookPoint *HP_map_vforeachnpc_post;
+struct HPMHookPoint *HP_map_vforeachregen_pre;
+struct HPMHookPoint *HP_map_vforeachregen_post;
+struct HPMHookPoint *HP_map_vforeachiddb_pre;
+struct HPMHookPoint *HP_map_vforeachiddb_post;
+struct HPMHookPoint *HP_map_vforeachinrange_pre;
+struct HPMHookPoint *HP_map_vforeachinrange_post;
+struct HPMHookPoint *HP_map_vforeachinshootrange_pre;
+struct HPMHookPoint *HP_map_vforeachinshootrange_post;
+struct HPMHookPoint *HP_map_vforeachinarea_pre;
+struct HPMHookPoint *HP_map_vforeachinarea_post;
+struct HPMHookPoint *HP_map_vforcountinrange_pre;
+struct HPMHookPoint *HP_map_vforcountinrange_post;
+struct HPMHookPoint *HP_map_vforcountinarea_pre;
+struct HPMHookPoint *HP_map_vforcountinarea_post;
+struct HPMHookPoint *HP_map_vforeachinmovearea_pre;
+struct HPMHookPoint *HP_map_vforeachinmovearea_post;
+struct HPMHookPoint *HP_map_vforeachincell_pre;
+struct HPMHookPoint *HP_map_vforeachincell_post;
+struct HPMHookPoint *HP_map_vforeachinpath_pre;
+struct HPMHookPoint *HP_map_vforeachinpath_post;
+struct HPMHookPoint *HP_map_vforeachinmap_pre;
+struct HPMHookPoint *HP_map_vforeachinmap_post;
+struct HPMHookPoint *HP_map_vforeachininstance_pre;
+struct HPMHookPoint *HP_map_vforeachininstance_post;
+struct HPMHookPoint *HP_map_id2sd_pre;
+struct HPMHookPoint *HP_map_id2sd_post;
+struct HPMHookPoint *HP_map_id2md_pre;
+struct HPMHookPoint *HP_map_id2md_post;
+struct HPMHookPoint *HP_map_id2nd_pre;
+struct HPMHookPoint *HP_map_id2nd_post;
+struct HPMHookPoint *HP_map_id2hd_pre;
+struct HPMHookPoint *HP_map_id2hd_post;
+struct HPMHookPoint *HP_map_id2mc_pre;
+struct HPMHookPoint *HP_map_id2mc_post;
+struct HPMHookPoint *HP_map_id2cd_pre;
+struct HPMHookPoint *HP_map_id2cd_post;
+struct HPMHookPoint *HP_map_id2bl_pre;
+struct HPMHookPoint *HP_map_id2bl_post;
+struct HPMHookPoint *HP_map_blid_exists_pre;
+struct HPMHookPoint *HP_map_blid_exists_post;
+struct HPMHookPoint *HP_map_mapindex2mapid_pre;
+struct HPMHookPoint *HP_map_mapindex2mapid_post;
+struct HPMHookPoint *HP_map_mapname2mapid_pre;
+struct HPMHookPoint *HP_map_mapname2mapid_post;
+struct HPMHookPoint *HP_map_mapname2ipport_pre;
+struct HPMHookPoint *HP_map_mapname2ipport_post;
+struct HPMHookPoint *HP_map_setipport_pre;
+struct HPMHookPoint *HP_map_setipport_post;
+struct HPMHookPoint *HP_map_eraseipport_pre;
+struct HPMHookPoint *HP_map_eraseipport_post;
+struct HPMHookPoint *HP_map_eraseallipport_pre;
+struct HPMHookPoint *HP_map_eraseallipport_post;
+struct HPMHookPoint *HP_map_addiddb_pre;
+struct HPMHookPoint *HP_map_addiddb_post;
+struct HPMHookPoint *HP_map_deliddb_pre;
+struct HPMHookPoint *HP_map_deliddb_post;
+struct HPMHookPoint *HP_map_nick2sd_pre;
+struct HPMHookPoint *HP_map_nick2sd_post;
+struct HPMHookPoint *HP_map_getmob_boss_pre;
+struct HPMHookPoint *HP_map_getmob_boss_post;
+struct HPMHookPoint *HP_map_id2boss_pre;
+struct HPMHookPoint *HP_map_id2boss_post;
+struct HPMHookPoint *HP_map_reloadnpc_pre;
+struct HPMHookPoint *HP_map_reloadnpc_post;
+struct HPMHookPoint *HP_map_check_dir_pre;
+struct HPMHookPoint *HP_map_check_dir_post;
+struct HPMHookPoint *HP_map_calc_dir_pre;
+struct HPMHookPoint *HP_map_calc_dir_post;
+struct HPMHookPoint *HP_map_random_dir_pre;
+struct HPMHookPoint *HP_map_random_dir_post;
+struct HPMHookPoint *HP_map_cleanup_sub_pre;
+struct HPMHookPoint *HP_map_cleanup_sub_post;
+struct HPMHookPoint *HP_map_delmap_pre;
+struct HPMHookPoint *HP_map_delmap_post;
+struct HPMHookPoint *HP_map_flags_init_pre;
+struct HPMHookPoint *HP_map_flags_init_post;
+struct HPMHookPoint *HP_map_iwall_set_pre;
+struct HPMHookPoint *HP_map_iwall_set_post;
+struct HPMHookPoint *HP_map_iwall_get_pre;
+struct HPMHookPoint *HP_map_iwall_get_post;
+struct HPMHookPoint *HP_map_iwall_remove_pre;
+struct HPMHookPoint *HP_map_iwall_remove_post;
+struct HPMHookPoint *HP_map_addmobtolist_pre;
+struct HPMHookPoint *HP_map_addmobtolist_post;
+struct HPMHookPoint *HP_map_spawnmobs_pre;
+struct HPMHookPoint *HP_map_spawnmobs_post;
+struct HPMHookPoint *HP_map_removemobs_pre;
+struct HPMHookPoint *HP_map_removemobs_post;
+struct HPMHookPoint *HP_map_addmap2db_pre;
+struct HPMHookPoint *HP_map_addmap2db_post;
+struct HPMHookPoint *HP_map_removemapdb_pre;
+struct HPMHookPoint *HP_map_removemapdb_post;
+struct HPMHookPoint *HP_map_clean_pre;
+struct HPMHookPoint *HP_map_clean_post;
+struct HPMHookPoint *HP_map_do_shutdown_pre;
+struct HPMHookPoint *HP_map_do_shutdown_post;
+struct HPMHookPoint *HP_map_freeblock_timer_pre;
+struct HPMHookPoint *HP_map_freeblock_timer_post;
+struct HPMHookPoint *HP_map_searchrandfreecell_pre;
+struct HPMHookPoint *HP_map_searchrandfreecell_post;
+struct HPMHookPoint *HP_map_count_sub_pre;
+struct HPMHookPoint *HP_map_count_sub_post;
+struct HPMHookPoint *HP_map_create_charid2nick_pre;
+struct HPMHookPoint *HP_map_create_charid2nick_post;
+struct HPMHookPoint *HP_map_removemobs_sub_pre;
+struct HPMHookPoint *HP_map_removemobs_sub_post;
+struct HPMHookPoint *HP_map_gat2cell_pre;
+struct HPMHookPoint *HP_map_gat2cell_post;
+struct HPMHookPoint *HP_map_cell2gat_pre;
+struct HPMHookPoint *HP_map_cell2gat_post;
+struct HPMHookPoint *HP_map_getcellp_pre;
+struct HPMHookPoint *HP_map_getcellp_post;
+struct HPMHookPoint *HP_map_setcell_pre;
+struct HPMHookPoint *HP_map_setcell_post;
+struct HPMHookPoint *HP_map_sub_getcellp_pre;
+struct HPMHookPoint *HP_map_sub_getcellp_post;
+struct HPMHookPoint *HP_map_sub_setcell_pre;
+struct HPMHookPoint *HP_map_sub_setcell_post;
+struct HPMHookPoint *HP_map_iwall_nextxy_pre;
+struct HPMHookPoint *HP_map_iwall_nextxy_post;
+struct HPMHookPoint *HP_map_create_map_data_other_server_pre;
+struct HPMHookPoint *HP_map_create_map_data_other_server_post;
+struct HPMHookPoint *HP_map_eraseallipport_sub_pre;
+struct HPMHookPoint *HP_map_eraseallipport_sub_post;
+struct HPMHookPoint *HP_map_init_mapcache_pre;
+struct HPMHookPoint *HP_map_init_mapcache_post;
+struct HPMHookPoint *HP_map_readfromcache_pre;
+struct HPMHookPoint *HP_map_readfromcache_post;
+struct HPMHookPoint *HP_map_addmap_pre;
+struct HPMHookPoint *HP_map_addmap_post;
+struct HPMHookPoint *HP_map_delmapid_pre;
+struct HPMHookPoint *HP_map_delmapid_post;
+struct HPMHookPoint *HP_map_zone_db_clear_pre;
+struct HPMHookPoint *HP_map_zone_db_clear_post;
+struct HPMHookPoint *HP_map_list_final_pre;
+struct HPMHookPoint *HP_map_list_final_post;
+struct HPMHookPoint *HP_map_waterheight_pre;
+struct HPMHookPoint *HP_map_waterheight_post;
+struct HPMHookPoint *HP_map_readgat_pre;
+struct HPMHookPoint *HP_map_readgat_post;
+struct HPMHookPoint *HP_map_readallmaps_pre;
+struct HPMHookPoint *HP_map_readallmaps_post;
+struct HPMHookPoint *HP_map_config_read_pre;
+struct HPMHookPoint *HP_map_config_read_post;
+struct HPMHookPoint *HP_map_config_read_sub_pre;
+struct HPMHookPoint *HP_map_config_read_sub_post;
+struct HPMHookPoint *HP_map_reloadnpc_sub_pre;
+struct HPMHookPoint *HP_map_reloadnpc_sub_post;
+struct HPMHookPoint *HP_map_inter_config_read_pre;
+struct HPMHookPoint *HP_map_inter_config_read_post;
+struct HPMHookPoint *HP_map_sql_init_pre;
+struct HPMHookPoint *HP_map_sql_init_post;
+struct HPMHookPoint *HP_map_sql_close_pre;
+struct HPMHookPoint *HP_map_sql_close_post;
+struct HPMHookPoint *HP_map_zone_mf_cache_pre;
+struct HPMHookPoint *HP_map_zone_mf_cache_post;
+struct HPMHookPoint *HP_map_zone_str2itemid_pre;
+struct HPMHookPoint *HP_map_zone_str2itemid_post;
+struct HPMHookPoint *HP_map_zone_str2skillid_pre;
+struct HPMHookPoint *HP_map_zone_str2skillid_post;
+struct HPMHookPoint *HP_map_zone_bl_type_pre;
+struct HPMHookPoint *HP_map_zone_bl_type_post;
+struct HPMHookPoint *HP_map_read_zone_db_pre;
+struct HPMHookPoint *HP_map_read_zone_db_post;
+struct HPMHookPoint *HP_map_db_final_pre;
+struct HPMHookPoint *HP_map_db_final_post;
+struct HPMHookPoint *HP_map_nick_db_final_pre;
+struct HPMHookPoint *HP_map_nick_db_final_post;
+struct HPMHookPoint *HP_map_cleanup_db_sub_pre;
+struct HPMHookPoint *HP_map_cleanup_db_sub_post;
+struct HPMHookPoint *HP_map_abort_sub_pre;
+struct HPMHookPoint *HP_map_abort_sub_post;
+struct HPMHookPoint *HP_map_helpscreen_pre;
+struct HPMHookPoint *HP_map_helpscreen_post;
+struct HPMHookPoint *HP_map_versionscreen_pre;
+struct HPMHookPoint *HP_map_versionscreen_post;
+struct HPMHookPoint *HP_map_arg_next_value_pre;
+struct HPMHookPoint *HP_map_arg_next_value_post;
+struct HPMHookPoint *HP_mapit_alloc_pre;
+struct HPMHookPoint *HP_mapit_alloc_post;
+struct HPMHookPoint *HP_mapit_free_pre;
+struct HPMHookPoint *HP_mapit_free_post;
+struct HPMHookPoint *HP_mapit_first_pre;
+struct HPMHookPoint *HP_mapit_first_post;
+struct HPMHookPoint *HP_mapit_last_pre;
+struct HPMHookPoint *HP_mapit_last_post;
+struct HPMHookPoint *HP_mapit_next_pre;
+struct HPMHookPoint *HP_mapit_next_post;
+struct HPMHookPoint *HP_mapit_prev_pre;
+struct HPMHookPoint *HP_mapit_prev_post;
+struct HPMHookPoint *HP_mapit_exists_pre;
+struct HPMHookPoint *HP_mapit_exists_post;
+struct HPMHookPoint *HP_mapreg_init_pre;
+struct HPMHookPoint *HP_mapreg_init_post;
+struct HPMHookPoint *HP_mapreg_final_pre;
+struct HPMHookPoint *HP_mapreg_final_post;
+struct HPMHookPoint *HP_mapreg_readreg_pre;
+struct HPMHookPoint *HP_mapreg_readreg_post;
+struct HPMHookPoint *HP_mapreg_readregstr_pre;
+struct HPMHookPoint *HP_mapreg_readregstr_post;
+struct HPMHookPoint *HP_mapreg_setreg_pre;
+struct HPMHookPoint *HP_mapreg_setreg_post;
+struct HPMHookPoint *HP_mapreg_setregstr_pre;
+struct HPMHookPoint *HP_mapreg_setregstr_post;
+struct HPMHookPoint *HP_mapreg_load_pre;
+struct HPMHookPoint *HP_mapreg_load_post;
+struct HPMHookPoint *HP_mapreg_save_pre;
+struct HPMHookPoint *HP_mapreg_save_post;
+struct HPMHookPoint *HP_mapreg_save_timer_pre;
+struct HPMHookPoint *HP_mapreg_save_timer_post;
+struct HPMHookPoint *HP_mapreg_reload_pre;
+struct HPMHookPoint *HP_mapreg_reload_post;
+struct HPMHookPoint *HP_mapreg_config_read_pre;
+struct HPMHookPoint *HP_mapreg_config_read_post;
+struct HPMHookPoint *HP_mercenary_init_pre;
+struct HPMHookPoint *HP_mercenary_init_post;
+struct HPMHookPoint *HP_mercenary_class_pre;
+struct HPMHookPoint *HP_mercenary_class_post;
+struct HPMHookPoint *HP_mercenary_get_viewdata_pre;
+struct HPMHookPoint *HP_mercenary_get_viewdata_post;
+struct HPMHookPoint *HP_mercenary_create_pre;
+struct HPMHookPoint *HP_mercenary_create_post;
+struct HPMHookPoint *HP_mercenary_data_received_pre;
+struct HPMHookPoint *HP_mercenary_data_received_post;
+struct HPMHookPoint *HP_mercenary_save_pre;
+struct HPMHookPoint *HP_mercenary_save_post;
+struct HPMHookPoint *HP_mercenary_heal_pre;
+struct HPMHookPoint *HP_mercenary_heal_post;
+struct HPMHookPoint *HP_mercenary_dead_pre;
+struct HPMHookPoint *HP_mercenary_dead_post;
+struct HPMHookPoint *HP_mercenary_delete_pre;
+struct HPMHookPoint *HP_mercenary_delete_post;
+struct HPMHookPoint *HP_mercenary_contract_stop_pre;
+struct HPMHookPoint *HP_mercenary_contract_stop_post;
+struct HPMHookPoint *HP_mercenary_get_lifetime_pre;
+struct HPMHookPoint *HP_mercenary_get_lifetime_post;
+struct HPMHookPoint *HP_mercenary_get_guild_pre;
+struct HPMHookPoint *HP_mercenary_get_guild_post;
+struct HPMHookPoint *HP_mercenary_get_faith_pre;
+struct HPMHookPoint *HP_mercenary_get_faith_post;
+struct HPMHookPoint *HP_mercenary_set_faith_pre;
+struct HPMHookPoint *HP_mercenary_set_faith_post;
+struct HPMHookPoint *HP_mercenary_get_calls_pre;
+struct HPMHookPoint *HP_mercenary_get_calls_post;
+struct HPMHookPoint *HP_mercenary_set_calls_pre;
+struct HPMHookPoint *HP_mercenary_set_calls_post;
+struct HPMHookPoint *HP_mercenary_kills_pre;
+struct HPMHookPoint *HP_mercenary_kills_post;
+struct HPMHookPoint *HP_mercenary_checkskill_pre;
+struct HPMHookPoint *HP_mercenary_checkskill_post;
+struct HPMHookPoint *HP_mercenary_read_db_pre;
+struct HPMHookPoint *HP_mercenary_read_db_post;
+struct HPMHookPoint *HP_mercenary_read_skilldb_pre;
+struct HPMHookPoint *HP_mercenary_read_skilldb_post;
+struct HPMHookPoint *HP_mercenary_killbonus_pre;
+struct HPMHookPoint *HP_mercenary_killbonus_post;
+struct HPMHookPoint *HP_mercenary_search_index_pre;
+struct HPMHookPoint *HP_mercenary_search_index_post;
+struct HPMHookPoint *HP_mercenary_contract_end_timer_pre;
+struct HPMHookPoint *HP_mercenary_contract_end_timer_post;
+struct HPMHookPoint *HP_mercenary_read_db_sub_pre;
+struct HPMHookPoint *HP_mercenary_read_db_sub_post;
+struct HPMHookPoint *HP_mercenary_read_skill_db_sub_pre;
+struct HPMHookPoint *HP_mercenary_read_skill_db_sub_post;
+struct HPMHookPoint *HP_mob_init_pre;
+struct HPMHookPoint *HP_mob_init_post;
+struct HPMHookPoint *HP_mob_final_pre;
+struct HPMHookPoint *HP_mob_final_post;
+struct HPMHookPoint *HP_mob_reload_pre;
+struct HPMHookPoint *HP_mob_reload_post;
+struct HPMHookPoint *HP_mob_db_pre;
+struct HPMHookPoint *HP_mob_db_post;
+struct HPMHookPoint *HP_mob_chat_pre;
+struct HPMHookPoint *HP_mob_chat_post;
+struct HPMHookPoint *HP_mob_makedummymobdb_pre;
+struct HPMHookPoint *HP_mob_makedummymobdb_post;
+struct HPMHookPoint *HP_mob_spawn_guardian_sub_pre;
+struct HPMHookPoint *HP_mob_spawn_guardian_sub_post;
+struct HPMHookPoint *HP_mob_skill_id2skill_idx_pre;
+struct HPMHookPoint *HP_mob_skill_id2skill_idx_post;
+struct HPMHookPoint *HP_mob_db_searchname_pre;
+struct HPMHookPoint *HP_mob_db_searchname_post;
+struct HPMHookPoint *HP_mob_db_searchname_array_sub_pre;
+struct HPMHookPoint *HP_mob_db_searchname_array_sub_post;
+struct HPMHookPoint *HP_mob_mvptomb_create_pre;
+struct HPMHookPoint *HP_mob_mvptomb_create_post;
+struct HPMHookPoint *HP_mob_mvptomb_destroy_pre;
+struct HPMHookPoint *HP_mob_mvptomb_destroy_post;
+struct HPMHookPoint *HP_mob_db_searchname_array_pre;
+struct HPMHookPoint *HP_mob_db_searchname_array_post;
+struct HPMHookPoint *HP_mob_db_checkid_pre;
+struct HPMHookPoint *HP_mob_db_checkid_post;
+struct HPMHookPoint *HP_mob_get_viewdata_pre;
+struct HPMHookPoint *HP_mob_get_viewdata_post;
+struct HPMHookPoint *HP_mob_parse_dataset_pre;
+struct HPMHookPoint *HP_mob_parse_dataset_post;
+struct HPMHookPoint *HP_mob_spawn_dataset_pre;
+struct HPMHookPoint *HP_mob_spawn_dataset_post;
+struct HPMHookPoint *HP_mob_get_random_id_pre;
+struct HPMHookPoint *HP_mob_get_random_id_post;
+struct HPMHookPoint *HP_mob_ksprotected_pre;
+struct HPMHookPoint *HP_mob_ksprotected_post;
+struct HPMHookPoint *HP_mob_once_spawn_sub_pre;
+struct HPMHookPoint *HP_mob_once_spawn_sub_post;
+struct HPMHookPoint *HP_mob_once_spawn_pre;
+struct HPMHookPoint *HP_mob_once_spawn_post;
+struct HPMHookPoint *HP_mob_once_spawn_area_pre;
+struct HPMHookPoint *HP_mob_once_spawn_area_post;
+struct HPMHookPoint *HP_mob_spawn_guardian_pre;
+struct HPMHookPoint *HP_mob_spawn_guardian_post;
+struct HPMHookPoint *HP_mob_spawn_bg_pre;
+struct HPMHookPoint *HP_mob_spawn_bg_post;
+struct HPMHookPoint *HP_mob_can_reach_pre;
+struct HPMHookPoint *HP_mob_can_reach_post;
+struct HPMHookPoint *HP_mob_linksearch_pre;
+struct HPMHookPoint *HP_mob_linksearch_post;
+struct HPMHookPoint *HP_mob_delayspawn_pre;
+struct HPMHookPoint *HP_mob_delayspawn_post;
+struct HPMHookPoint *HP_mob_setdelayspawn_pre;
+struct HPMHookPoint *HP_mob_setdelayspawn_post;
+struct HPMHookPoint *HP_mob_count_sub_pre;
+struct HPMHookPoint *HP_mob_count_sub_post;
+struct HPMHookPoint *HP_mob_spawn_pre;
+struct HPMHookPoint *HP_mob_spawn_post;
+struct HPMHookPoint *HP_mob_can_changetarget_pre;
+struct HPMHookPoint *HP_mob_can_changetarget_post;
+struct HPMHookPoint *HP_mob_target_pre;
+struct HPMHookPoint *HP_mob_target_post;
+struct HPMHookPoint *HP_mob_ai_sub_hard_activesearch_pre;
+struct HPMHookPoint *HP_mob_ai_sub_hard_activesearch_post;
+struct HPMHookPoint *HP_mob_ai_sub_hard_changechase_pre;
+struct HPMHookPoint *HP_mob_ai_sub_hard_changechase_post;
+struct HPMHookPoint *HP_mob_ai_sub_hard_bg_ally_pre;
+struct HPMHookPoint *HP_mob_ai_sub_hard_bg_ally_post;
+struct HPMHookPoint *HP_mob_ai_sub_hard_lootsearch_pre;
+struct HPMHookPoint *HP_mob_ai_sub_hard_lootsearch_post;
+struct HPMHookPoint *HP_mob_warpchase_sub_pre;
+struct HPMHookPoint *HP_mob_warpchase_sub_post;
+struct HPMHookPoint *HP_mob_ai_sub_hard_slavemob_pre;
+struct HPMHookPoint *HP_mob_ai_sub_hard_slavemob_post;
+struct HPMHookPoint *HP_mob_unlocktarget_pre;
+struct HPMHookPoint *HP_mob_unlocktarget_post;
+struct HPMHookPoint *HP_mob_randomwalk_pre;
+struct HPMHookPoint *HP_mob_randomwalk_post;
+struct HPMHookPoint *HP_mob_warpchase_pre;
+struct HPMHookPoint *HP_mob_warpchase_post;
+struct HPMHookPoint *HP_mob_ai_sub_hard_pre;
+struct HPMHookPoint *HP_mob_ai_sub_hard_post;
+struct HPMHookPoint *HP_mob_ai_sub_hard_timer_pre;
+struct HPMHookPoint *HP_mob_ai_sub_hard_timer_post;
+struct HPMHookPoint *HP_mob_ai_sub_foreachclient_pre;
+struct HPMHookPoint *HP_mob_ai_sub_foreachclient_post;
+struct HPMHookPoint *HP_mob_ai_sub_lazy_pre;
+struct HPMHookPoint *HP_mob_ai_sub_lazy_post;
+struct HPMHookPoint *HP_mob_ai_lazy_pre;
+struct HPMHookPoint *HP_mob_ai_lazy_post;
+struct HPMHookPoint *HP_mob_ai_hard_pre;
+struct HPMHookPoint *HP_mob_ai_hard_post;
+struct HPMHookPoint *HP_mob_setdropitem_pre;
+struct HPMHookPoint *HP_mob_setdropitem_post;
+struct HPMHookPoint *HP_mob_setlootitem_pre;
+struct HPMHookPoint *HP_mob_setlootitem_post;
+struct HPMHookPoint *HP_mob_delay_item_drop_pre;
+struct HPMHookPoint *HP_mob_delay_item_drop_post;
+struct HPMHookPoint *HP_mob_item_drop_pre;
+struct HPMHookPoint *HP_mob_item_drop_post;
+struct HPMHookPoint *HP_mob_timer_delete_pre;
+struct HPMHookPoint *HP_mob_timer_delete_post;
+struct HPMHookPoint *HP_mob_deleteslave_sub_pre;
+struct HPMHookPoint *HP_mob_deleteslave_sub_post;
+struct HPMHookPoint *HP_mob_deleteslave_pre;
+struct HPMHookPoint *HP_mob_deleteslave_post;
+struct HPMHookPoint *HP_mob_respawn_pre;
+struct HPMHookPoint *HP_mob_respawn_post;
+struct HPMHookPoint *HP_mob_log_damage_pre;
+struct HPMHookPoint *HP_mob_log_damage_post;
+struct HPMHookPoint *HP_mob_damage_pre;
+struct HPMHookPoint *HP_mob_damage_post;
+struct HPMHookPoint *HP_mob_dead_pre;
+struct HPMHookPoint *HP_mob_dead_post;
+struct HPMHookPoint *HP_mob_revive_pre;
+struct HPMHookPoint *HP_mob_revive_post;
+struct HPMHookPoint *HP_mob_guardian_guildchange_pre;
+struct HPMHookPoint *HP_mob_guardian_guildchange_post;
+struct HPMHookPoint *HP_mob_random_class_pre;
+struct HPMHookPoint *HP_mob_random_class_post;
+struct HPMHookPoint *HP_mob_class_change_pre;
+struct HPMHookPoint *HP_mob_class_change_post;
+struct HPMHookPoint *HP_mob_heal_pre;
+struct HPMHookPoint *HP_mob_heal_post;
+struct HPMHookPoint *HP_mob_warpslave_sub_pre;
+struct HPMHookPoint *HP_mob_warpslave_sub_post;
+struct HPMHookPoint *HP_mob_warpslave_pre;
+struct HPMHookPoint *HP_mob_warpslave_post;
+struct HPMHookPoint *HP_mob_countslave_sub_pre;
+struct HPMHookPoint *HP_mob_countslave_sub_post;
+struct HPMHookPoint *HP_mob_countslave_pre;
+struct HPMHookPoint *HP_mob_countslave_post;
+struct HPMHookPoint *HP_mob_summonslave_pre;
+struct HPMHookPoint *HP_mob_summonslave_post;
+struct HPMHookPoint *HP_mob_getfriendhprate_sub_pre;
+struct HPMHookPoint *HP_mob_getfriendhprate_sub_post;
+struct HPMHookPoint *HP_mob_getfriendhprate_pre;
+struct HPMHookPoint *HP_mob_getfriendhprate_post;
+struct HPMHookPoint *HP_mob_getmasterhpltmaxrate_pre;
+struct HPMHookPoint *HP_mob_getmasterhpltmaxrate_post;
+struct HPMHookPoint *HP_mob_getfriendstatus_sub_pre;
+struct HPMHookPoint *HP_mob_getfriendstatus_sub_post;
+struct HPMHookPoint *HP_mob_getfriendstatus_pre;
+struct HPMHookPoint *HP_mob_getfriendstatus_post;
+struct HPMHookPoint *HP_mob_skill_use_pre;
+struct HPMHookPoint *HP_mob_skill_use_post;
+struct HPMHookPoint *HP_mob_skill_event_pre;
+struct HPMHookPoint *HP_mob_skill_event_post;
+struct HPMHookPoint *HP_mob_is_clone_pre;
+struct HPMHookPoint *HP_mob_is_clone_post;
+struct HPMHookPoint *HP_mob_clone_spawn_pre;
+struct HPMHookPoint *HP_mob_clone_spawn_post;
+struct HPMHookPoint *HP_mob_clone_delete_pre;
+struct HPMHookPoint *HP_mob_clone_delete_post;
+struct HPMHookPoint *HP_mob_drop_adjust_pre;
+struct HPMHookPoint *HP_mob_drop_adjust_post;
+struct HPMHookPoint *HP_mob_item_dropratio_adjust_pre;
+struct HPMHookPoint *HP_mob_item_dropratio_adjust_post;
+struct HPMHookPoint *HP_mob_parse_dbrow_pre;
+struct HPMHookPoint *HP_mob_parse_dbrow_post;
+struct HPMHookPoint *HP_mob_readdb_sub_pre;
+struct HPMHookPoint *HP_mob_readdb_sub_post;
+struct HPMHookPoint *HP_mob_readdb_pre;
+struct HPMHookPoint *HP_mob_readdb_post;
+struct HPMHookPoint *HP_mob_read_sqldb_pre;
+struct HPMHookPoint *HP_mob_read_sqldb_post;
+struct HPMHookPoint *HP_mob_readdb_mobavail_pre;
+struct HPMHookPoint *HP_mob_readdb_mobavail_post;
+struct HPMHookPoint *HP_mob_read_randommonster_pre;
+struct HPMHookPoint *HP_mob_read_randommonster_post;
+struct HPMHookPoint *HP_mob_parse_row_chatdb_pre;
+struct HPMHookPoint *HP_mob_parse_row_chatdb_post;
+struct HPMHookPoint *HP_mob_readchatdb_pre;
+struct HPMHookPoint *HP_mob_readchatdb_post;
+struct HPMHookPoint *HP_mob_parse_row_mobskilldb_pre;
+struct HPMHookPoint *HP_mob_parse_row_mobskilldb_post;
+struct HPMHookPoint *HP_mob_readskilldb_pre;
+struct HPMHookPoint *HP_mob_readskilldb_post;
+struct HPMHookPoint *HP_mob_read_sqlskilldb_pre;
+struct HPMHookPoint *HP_mob_read_sqlskilldb_post;
+struct HPMHookPoint *HP_mob_readdb_race2_pre;
+struct HPMHookPoint *HP_mob_readdb_race2_post;
+struct HPMHookPoint *HP_mob_readdb_itemratio_pre;
+struct HPMHookPoint *HP_mob_readdb_itemratio_post;
+struct HPMHookPoint *HP_mob_load_pre;
+struct HPMHookPoint *HP_mob_load_post;
+struct HPMHookPoint *HP_mob_clear_spawninfo_pre;
+struct HPMHookPoint *HP_mob_clear_spawninfo_post;
+struct HPMHookPoint *HP_npc_init_pre;
+struct HPMHookPoint *HP_npc_init_post;
+struct HPMHookPoint *HP_npc_final_pre;
+struct HPMHookPoint *HP_npc_final_post;
+struct HPMHookPoint *HP_npc_get_new_npc_id_pre;
+struct HPMHookPoint *HP_npc_get_new_npc_id_post;
+struct HPMHookPoint *HP_npc_get_viewdata_pre;
+struct HPMHookPoint *HP_npc_get_viewdata_post;
+struct HPMHookPoint *HP_npc_isnear_sub_pre;
+struct HPMHookPoint *HP_npc_isnear_sub_post;
+struct HPMHookPoint *HP_npc_isnear_pre;
+struct HPMHookPoint *HP_npc_isnear_post;
+struct HPMHookPoint *HP_npc_ontouch_event_pre;
+struct HPMHookPoint *HP_npc_ontouch_event_post;
+struct HPMHookPoint *HP_npc_ontouch2_event_pre;
+struct HPMHookPoint *HP_npc_ontouch2_event_post;
+struct HPMHookPoint *HP_npc_enable_sub_pre;
+struct HPMHookPoint *HP_npc_enable_sub_post;
+struct HPMHookPoint *HP_npc_enable_pre;
+struct HPMHookPoint *HP_npc_enable_post;
+struct HPMHookPoint *HP_npc_name2id_pre;
+struct HPMHookPoint *HP_npc_name2id_post;
+struct HPMHookPoint *HP_npc_event_dequeue_pre;
+struct HPMHookPoint *HP_npc_event_dequeue_post;
+struct HPMHookPoint *HP_npc_event_export_create_pre;
+struct HPMHookPoint *HP_npc_event_export_create_post;
+struct HPMHookPoint *HP_npc_event_export_pre;
+struct HPMHookPoint *HP_npc_event_export_post;
+struct HPMHookPoint *HP_npc_event_sub_pre;
+struct HPMHookPoint *HP_npc_event_sub_post;
+struct HPMHookPoint *HP_npc_event_doall_sub_pre;
+struct HPMHookPoint *HP_npc_event_doall_sub_post;
+struct HPMHookPoint *HP_npc_event_do_pre;
+struct HPMHookPoint *HP_npc_event_do_post;
+struct HPMHookPoint *HP_npc_event_doall_id_pre;
+struct HPMHookPoint *HP_npc_event_doall_id_post;
+struct HPMHookPoint *HP_npc_event_doall_pre;
+struct HPMHookPoint *HP_npc_event_doall_post;
+struct HPMHookPoint *HP_npc_event_do_clock_pre;
+struct HPMHookPoint *HP_npc_event_do_clock_post;
+struct HPMHookPoint *HP_npc_event_do_oninit_pre;
+struct HPMHookPoint *HP_npc_event_do_oninit_post;
+struct HPMHookPoint *HP_npc_timerevent_export_pre;
+struct HPMHookPoint *HP_npc_timerevent_export_post;
+struct HPMHookPoint *HP_npc_timerevent_pre;
+struct HPMHookPoint *HP_npc_timerevent_post;
+struct HPMHookPoint *HP_npc_timerevent_start_pre;
+struct HPMHookPoint *HP_npc_timerevent_start_post;
+struct HPMHookPoint *HP_npc_timerevent_stop_pre;
+struct HPMHookPoint *HP_npc_timerevent_stop_post;
+struct HPMHookPoint *HP_npc_timerevent_quit_pre;
+struct HPMHookPoint *HP_npc_timerevent_quit_post;
+struct HPMHookPoint *HP_npc_gettimerevent_tick_pre;
+struct HPMHookPoint *HP_npc_gettimerevent_tick_post;
+struct HPMHookPoint *HP_npc_settimerevent_tick_pre;
+struct HPMHookPoint *HP_npc_settimerevent_tick_post;
+struct HPMHookPoint *HP_npc_event_pre;
+struct HPMHookPoint *HP_npc_event_post;
+struct HPMHookPoint *HP_npc_touch_areanpc_sub_pre;
+struct HPMHookPoint *HP_npc_touch_areanpc_sub_post;
+struct HPMHookPoint *HP_npc_touchnext_areanpc_pre;
+struct HPMHookPoint *HP_npc_touchnext_areanpc_post;
+struct HPMHookPoint *HP_npc_touch_areanpc_pre;
+struct HPMHookPoint *HP_npc_touch_areanpc_post;
+struct HPMHookPoint *HP_npc_touch_areanpc2_pre;
+struct HPMHookPoint *HP_npc_touch_areanpc2_post;
+struct HPMHookPoint *HP_npc_check_areanpc_pre;
+struct HPMHookPoint *HP_npc_check_areanpc_post;
+struct HPMHookPoint *HP_npc_checknear_pre;
+struct HPMHookPoint *HP_npc_checknear_post;
+struct HPMHookPoint *HP_npc_globalmessage_pre;
+struct HPMHookPoint *HP_npc_globalmessage_post;
+struct HPMHookPoint *HP_npc_run_tomb_pre;
+struct HPMHookPoint *HP_npc_run_tomb_post;
+struct HPMHookPoint *HP_npc_click_pre;
+struct HPMHookPoint *HP_npc_click_post;
+struct HPMHookPoint *HP_npc_scriptcont_pre;
+struct HPMHookPoint *HP_npc_scriptcont_post;
+struct HPMHookPoint *HP_npc_buysellsel_pre;
+struct HPMHookPoint *HP_npc_buysellsel_post;
+struct HPMHookPoint *HP_npc_cashshop_buylist_pre;
+struct HPMHookPoint *HP_npc_cashshop_buylist_post;
+struct HPMHookPoint *HP_npc_buylist_sub_pre;
+struct HPMHookPoint *HP_npc_buylist_sub_post;
+struct HPMHookPoint *HP_npc_cashshop_buy_pre;
+struct HPMHookPoint *HP_npc_cashshop_buy_post;
+struct HPMHookPoint *HP_npc_buylist_pre;
+struct HPMHookPoint *HP_npc_buylist_post;
+struct HPMHookPoint *HP_npc_selllist_sub_pre;
+struct HPMHookPoint *HP_npc_selllist_sub_post;
+struct HPMHookPoint *HP_npc_selllist_pre;
+struct HPMHookPoint *HP_npc_selllist_post;
+struct HPMHookPoint *HP_npc_remove_map_pre;
+struct HPMHookPoint *HP_npc_remove_map_post;
+struct HPMHookPoint *HP_npc_unload_ev_pre;
+struct HPMHookPoint *HP_npc_unload_ev_post;
+struct HPMHookPoint *HP_npc_unload_ev_label_pre;
+struct HPMHookPoint *HP_npc_unload_ev_label_post;
+struct HPMHookPoint *HP_npc_unload_dup_sub_pre;
+struct HPMHookPoint *HP_npc_unload_dup_sub_post;
+struct HPMHookPoint *HP_npc_unload_duplicates_pre;
+struct HPMHookPoint *HP_npc_unload_duplicates_post;
+struct HPMHookPoint *HP_npc_unload_pre;
+struct HPMHookPoint *HP_npc_unload_post;
+struct HPMHookPoint *HP_npc_clearsrcfile_pre;
+struct HPMHookPoint *HP_npc_clearsrcfile_post;
+struct HPMHookPoint *HP_npc_addsrcfile_pre;
+struct HPMHookPoint *HP_npc_addsrcfile_post;
+struct HPMHookPoint *HP_npc_delsrcfile_pre;
+struct HPMHookPoint *HP_npc_delsrcfile_post;
+struct HPMHookPoint *HP_npc_parsename_pre;
+struct HPMHookPoint *HP_npc_parsename_post;
+struct HPMHookPoint *HP_npc_add_warp_pre;
+struct HPMHookPoint *HP_npc_add_warp_post;
+struct HPMHookPoint *HP_npc_parse_warp_pre;
+struct HPMHookPoint *HP_npc_parse_warp_post;
+struct HPMHookPoint *HP_npc_parse_shop_pre;
+struct HPMHookPoint *HP_npc_parse_shop_post;
+struct HPMHookPoint *HP_npc_convertlabel_db_pre;
+struct HPMHookPoint *HP_npc_convertlabel_db_post;
+struct HPMHookPoint *HP_npc_skip_script_pre;
+struct HPMHookPoint *HP_npc_skip_script_post;
+struct HPMHookPoint *HP_npc_parse_script_pre;
+struct HPMHookPoint *HP_npc_parse_script_post;
+struct HPMHookPoint *HP_npc_parse_duplicate_pre;
+struct HPMHookPoint *HP_npc_parse_duplicate_post;
+struct HPMHookPoint *HP_npc_duplicate4instance_pre;
+struct HPMHookPoint *HP_npc_duplicate4instance_post;
+struct HPMHookPoint *HP_npc_setcells_pre;
+struct HPMHookPoint *HP_npc_setcells_post;
+struct HPMHookPoint *HP_npc_unsetcells_sub_pre;
+struct HPMHookPoint *HP_npc_unsetcells_sub_post;
+struct HPMHookPoint *HP_npc_unsetcells_pre;
+struct HPMHookPoint *HP_npc_unsetcells_post;
+struct HPMHookPoint *HP_npc_movenpc_pre;
+struct HPMHookPoint *HP_npc_movenpc_post;
+struct HPMHookPoint *HP_npc_setdisplayname_pre;
+struct HPMHookPoint *HP_npc_setdisplayname_post;
+struct HPMHookPoint *HP_npc_setclass_pre;
+struct HPMHookPoint *HP_npc_setclass_post;
+struct HPMHookPoint *HP_npc_do_atcmd_event_pre;
+struct HPMHookPoint *HP_npc_do_atcmd_event_post;
+struct HPMHookPoint *HP_npc_parse_function_pre;
+struct HPMHookPoint *HP_npc_parse_function_post;
+struct HPMHookPoint *HP_npc_parse_mob2_pre;
+struct HPMHookPoint *HP_npc_parse_mob2_post;
+struct HPMHookPoint *HP_npc_parse_mob_pre;
+struct HPMHookPoint *HP_npc_parse_mob_post;
+struct HPMHookPoint *HP_npc_parse_mapflag_pre;
+struct HPMHookPoint *HP_npc_parse_mapflag_post;
+struct HPMHookPoint *HP_npc_parsesrcfile_pre;
+struct HPMHookPoint *HP_npc_parsesrcfile_post;
+struct HPMHookPoint *HP_npc_script_event_pre;
+struct HPMHookPoint *HP_npc_script_event_post;
+struct HPMHookPoint *HP_npc_read_event_script_pre;
+struct HPMHookPoint *HP_npc_read_event_script_post;
+struct HPMHookPoint *HP_npc_path_db_clear_sub_pre;
+struct HPMHookPoint *HP_npc_path_db_clear_sub_post;
+struct HPMHookPoint *HP_npc_ev_label_db_clear_sub_pre;
+struct HPMHookPoint *HP_npc_ev_label_db_clear_sub_post;
+struct HPMHookPoint *HP_npc_reload_pre;
+struct HPMHookPoint *HP_npc_reload_post;
+struct HPMHookPoint *HP_npc_unloadfile_pre;
+struct HPMHookPoint *HP_npc_unloadfile_post;
+struct HPMHookPoint *HP_npc_do_clear_npc_pre;
+struct HPMHookPoint *HP_npc_do_clear_npc_post;
+struct HPMHookPoint *HP_npc_debug_warps_sub_pre;
+struct HPMHookPoint *HP_npc_debug_warps_sub_post;
+struct HPMHookPoint *HP_npc_debug_warps_pre;
+struct HPMHookPoint *HP_npc_debug_warps_post;
+struct HPMHookPoint *HP_party_init_pre;
+struct HPMHookPoint *HP_party_init_post;
+struct HPMHookPoint *HP_party_final_pre;
+struct HPMHookPoint *HP_party_final_post;
+struct HPMHookPoint *HP_party_search_pre;
+struct HPMHookPoint *HP_party_search_post;
+struct HPMHookPoint *HP_party_searchname_pre;
+struct HPMHookPoint *HP_party_searchname_post;
+struct HPMHookPoint *HP_party_getmemberid_pre;
+struct HPMHookPoint *HP_party_getmemberid_post;
+struct HPMHookPoint *HP_party_getavailablesd_pre;
+struct HPMHookPoint *HP_party_getavailablesd_post;
+struct HPMHookPoint *HP_party_create_pre;
+struct HPMHookPoint *HP_party_create_post;
+struct HPMHookPoint *HP_party_created_pre;
+struct HPMHookPoint *HP_party_created_post;
+struct HPMHookPoint *HP_party_request_info_pre;
+struct HPMHookPoint *HP_party_request_info_post;
+struct HPMHookPoint *HP_party_invite_pre;
+struct HPMHookPoint *HP_party_invite_post;
+struct HPMHookPoint *HP_party_member_joined_pre;
+struct HPMHookPoint *HP_party_member_joined_post;
+struct HPMHookPoint *HP_party_member_added_pre;
+struct HPMHookPoint *HP_party_member_added_post;
+struct HPMHookPoint *HP_party_leave_pre;
+struct HPMHookPoint *HP_party_leave_post;
+struct HPMHookPoint *HP_party_removemember_pre;
+struct HPMHookPoint *HP_party_removemember_post;
+struct HPMHookPoint *HP_party_member_withdraw_pre;
+struct HPMHookPoint *HP_party_member_withdraw_post;
+struct HPMHookPoint *HP_party_reply_invite_pre;
+struct HPMHookPoint *HP_party_reply_invite_post;
+struct HPMHookPoint *HP_party_recv_noinfo_pre;
+struct HPMHookPoint *HP_party_recv_noinfo_post;
+struct HPMHookPoint *HP_party_recv_info_pre;
+struct HPMHookPoint *HP_party_recv_info_post;
+struct HPMHookPoint *HP_party_recv_movemap_pre;
+struct HPMHookPoint *HP_party_recv_movemap_post;
+struct HPMHookPoint *HP_party_broken_pre;
+struct HPMHookPoint *HP_party_broken_post;
+struct HPMHookPoint *HP_party_optionchanged_pre;
+struct HPMHookPoint *HP_party_optionchanged_post;
+struct HPMHookPoint *HP_party_changeoption_pre;
+struct HPMHookPoint *HP_party_changeoption_post;
+struct HPMHookPoint *HP_party_changeleader_pre;
+struct HPMHookPoint *HP_party_changeleader_post;
+struct HPMHookPoint *HP_party_send_movemap_pre;
+struct HPMHookPoint *HP_party_send_movemap_post;
+struct HPMHookPoint *HP_party_send_levelup_pre;
+struct HPMHookPoint *HP_party_send_levelup_post;
+struct HPMHookPoint *HP_party_send_logout_pre;
+struct HPMHookPoint *HP_party_send_logout_post;
+struct HPMHookPoint *HP_party_send_message_pre;
+struct HPMHookPoint *HP_party_send_message_post;
+struct HPMHookPoint *HP_party_recv_message_pre;
+struct HPMHookPoint *HP_party_recv_message_post;
+struct HPMHookPoint *HP_party_skill_check_pre;
+struct HPMHookPoint *HP_party_skill_check_post;
+struct HPMHookPoint *HP_party_send_xy_clear_pre;
+struct HPMHookPoint *HP_party_send_xy_clear_post;
+struct HPMHookPoint *HP_party_exp_share_pre;
+struct HPMHookPoint *HP_party_exp_share_post;
+struct HPMHookPoint *HP_party_share_loot_pre;
+struct HPMHookPoint *HP_party_share_loot_post;
+struct HPMHookPoint *HP_party_send_dot_remove_pre;
+struct HPMHookPoint *HP_party_send_dot_remove_post;
+struct HPMHookPoint *HP_party_sub_count_pre;
+struct HPMHookPoint *HP_party_sub_count_post;
+struct HPMHookPoint *HP_party_booking_register_pre;
+struct HPMHookPoint *HP_party_booking_register_post;
+struct HPMHookPoint *HP_party_booking_update_pre;
+struct HPMHookPoint *HP_party_booking_update_post;
+struct HPMHookPoint *HP_party_booking_search_pre;
+struct HPMHookPoint *HP_party_booking_search_post;
+struct HPMHookPoint *HP_party_booking_delete_pre;
+struct HPMHookPoint *HP_party_booking_delete_post;
+struct HPMHookPoint *HP_party_vforeachsamemap_pre;
+struct HPMHookPoint *HP_party_vforeachsamemap_post;
+struct HPMHookPoint *HP_party_send_xy_timer_pre;
+struct HPMHookPoint *HP_party_send_xy_timer_post;
+struct HPMHookPoint *HP_party_fill_member_pre;
+struct HPMHookPoint *HP_party_fill_member_post;
+struct HPMHookPoint *HP_party_sd_check_pre;
+struct HPMHookPoint *HP_party_sd_check_post;
+struct HPMHookPoint *HP_party_check_state_pre;
+struct HPMHookPoint *HP_party_check_state_post;
+struct HPMHookPoint *HP_party_create_booking_data_pre;
+struct HPMHookPoint *HP_party_create_booking_data_post;
+struct HPMHookPoint *HP_party_db_final_pre;
+struct HPMHookPoint *HP_party_db_final_post;
+struct HPMHookPoint *HP_path_blownpos_pre;
+struct HPMHookPoint *HP_path_blownpos_post;
+struct HPMHookPoint *HP_path_search_pre;
+struct HPMHookPoint *HP_path_search_post;
+struct HPMHookPoint *HP_path_search_long_pre;
+struct HPMHookPoint *HP_path_search_long_post;
+struct HPMHookPoint *HP_path_check_distance_pre;
+struct HPMHookPoint *HP_path_check_distance_post;
+struct HPMHookPoint *HP_path_distance_pre;
+struct HPMHookPoint *HP_path_distance_post;
+struct HPMHookPoint *HP_pc_init_pre;
+struct HPMHookPoint *HP_pc_init_post;
+struct HPMHookPoint *HP_pc_final_pre;
+struct HPMHookPoint *HP_pc_final_post;
+struct HPMHookPoint *HP_pc_get_dummy_sd_pre;
+struct HPMHookPoint *HP_pc_get_dummy_sd_post;
+struct HPMHookPoint *HP_pc_class2idx_pre;
+struct HPMHookPoint *HP_pc_class2idx_post;
+struct HPMHookPoint *HP_pc_get_group_level_pre;
+struct HPMHookPoint *HP_pc_get_group_level_post;
+struct HPMHookPoint *HP_pc_can_give_items_pre;
+struct HPMHookPoint *HP_pc_can_give_items_post;
+struct HPMHookPoint *HP_pc_can_use_command_pre;
+struct HPMHookPoint *HP_pc_can_use_command_post;
+struct HPMHookPoint *HP_pc_has_permission_pre;
+struct HPMHookPoint *HP_pc_has_permission_post;
+struct HPMHookPoint *HP_pc_set_group_pre;
+struct HPMHookPoint *HP_pc_set_group_post;
+struct HPMHookPoint *HP_pc_should_log_commands_pre;
+struct HPMHookPoint *HP_pc_should_log_commands_post;
+struct HPMHookPoint *HP_pc_setrestartvalue_pre;
+struct HPMHookPoint *HP_pc_setrestartvalue_post;
+struct HPMHookPoint *HP_pc_makesavestatus_pre;
+struct HPMHookPoint *HP_pc_makesavestatus_post;
+struct HPMHookPoint *HP_pc_respawn_pre;
+struct HPMHookPoint *HP_pc_respawn_post;
+struct HPMHookPoint *HP_pc_setnewpc_pre;
+struct HPMHookPoint *HP_pc_setnewpc_post;
+struct HPMHookPoint *HP_pc_authok_pre;
+struct HPMHookPoint *HP_pc_authok_post;
+struct HPMHookPoint *HP_pc_authfail_pre;
+struct HPMHookPoint *HP_pc_authfail_post;
+struct HPMHookPoint *HP_pc_reg_received_pre;
+struct HPMHookPoint *HP_pc_reg_received_post;
+struct HPMHookPoint *HP_pc_isequip_pre;
+struct HPMHookPoint *HP_pc_isequip_post;
+struct HPMHookPoint *HP_pc_equippoint_pre;
+struct HPMHookPoint *HP_pc_equippoint_post;
+struct HPMHookPoint *HP_pc_setinventorydata_pre;
+struct HPMHookPoint *HP_pc_setinventorydata_post;
+struct HPMHookPoint *HP_pc_checkskill_pre;
+struct HPMHookPoint *HP_pc_checkskill_post;
+struct HPMHookPoint *HP_pc_checkskill2_pre;
+struct HPMHookPoint *HP_pc_checkskill2_post;
+struct HPMHookPoint *HP_pc_checkallowskill_pre;
+struct HPMHookPoint *HP_pc_checkallowskill_post;
+struct HPMHookPoint *HP_pc_checkequip_pre;
+struct HPMHookPoint *HP_pc_checkequip_post;
+struct HPMHookPoint *HP_pc_calc_skilltree_pre;
+struct HPMHookPoint *HP_pc_calc_skilltree_post;
+struct HPMHookPoint *HP_pc_calc_skilltree_normalize_job_pre;
+struct HPMHookPoint *HP_pc_calc_skilltree_normalize_job_post;
+struct HPMHookPoint *HP_pc_clean_skilltree_pre;
+struct HPMHookPoint *HP_pc_clean_skilltree_post;
+struct HPMHookPoint *HP_pc_setpos_pre;
+struct HPMHookPoint *HP_pc_setpos_post;
+struct HPMHookPoint *HP_pc_setsavepoint_pre;
+struct HPMHookPoint *HP_pc_setsavepoint_post;
+struct HPMHookPoint *HP_pc_randomwarp_pre;
+struct HPMHookPoint *HP_pc_randomwarp_post;
+struct HPMHookPoint *HP_pc_memo_pre;
+struct HPMHookPoint *HP_pc_memo_post;
+struct HPMHookPoint *HP_pc_checkadditem_pre;
+struct HPMHookPoint *HP_pc_checkadditem_post;
+struct HPMHookPoint *HP_pc_inventoryblank_pre;
+struct HPMHookPoint *HP_pc_inventoryblank_post;
+struct HPMHookPoint *HP_pc_search_inventory_pre;
+struct HPMHookPoint *HP_pc_search_inventory_post;
+struct HPMHookPoint *HP_pc_payzeny_pre;
+struct HPMHookPoint *HP_pc_payzeny_post;
+struct HPMHookPoint *HP_pc_additem_pre;
+struct HPMHookPoint *HP_pc_additem_post;
+struct HPMHookPoint *HP_pc_getzeny_pre;
+struct HPMHookPoint *HP_pc_getzeny_post;
+struct HPMHookPoint *HP_pc_delitem_pre;
+struct HPMHookPoint *HP_pc_delitem_post;
+struct HPMHookPoint *HP_pc_paycash_pre;
+struct HPMHookPoint *HP_pc_paycash_post;
+struct HPMHookPoint *HP_pc_getcash_pre;
+struct HPMHookPoint *HP_pc_getcash_post;
+struct HPMHookPoint *HP_pc_cart_additem_pre;
+struct HPMHookPoint *HP_pc_cart_additem_post;
+struct HPMHookPoint *HP_pc_cart_delitem_pre;
+struct HPMHookPoint *HP_pc_cart_delitem_post;
+struct HPMHookPoint *HP_pc_putitemtocart_pre;
+struct HPMHookPoint *HP_pc_putitemtocart_post;
+struct HPMHookPoint *HP_pc_getitemfromcart_pre;
+struct HPMHookPoint *HP_pc_getitemfromcart_post;
+struct HPMHookPoint *HP_pc_cartitem_amount_pre;
+struct HPMHookPoint *HP_pc_cartitem_amount_post;
+struct HPMHookPoint *HP_pc_takeitem_pre;
+struct HPMHookPoint *HP_pc_takeitem_post;
+struct HPMHookPoint *HP_pc_dropitem_pre;
+struct HPMHookPoint *HP_pc_dropitem_post;
+struct HPMHookPoint *HP_pc_isequipped_pre;
+struct HPMHookPoint *HP_pc_isequipped_post;
+struct HPMHookPoint *HP_pc_can_Adopt_pre;
+struct HPMHookPoint *HP_pc_can_Adopt_post;
+struct HPMHookPoint *HP_pc_adoption_pre;
+struct HPMHookPoint *HP_pc_adoption_post;
+struct HPMHookPoint *HP_pc_updateweightstatus_pre;
+struct HPMHookPoint *HP_pc_updateweightstatus_post;
+struct HPMHookPoint *HP_pc_addautobonus_pre;
+struct HPMHookPoint *HP_pc_addautobonus_post;
+struct HPMHookPoint *HP_pc_exeautobonus_pre;
+struct HPMHookPoint *HP_pc_exeautobonus_post;
+struct HPMHookPoint *HP_pc_endautobonus_pre;
+struct HPMHookPoint *HP_pc_endautobonus_post;
+struct HPMHookPoint *HP_pc_delautobonus_pre;
+struct HPMHookPoint *HP_pc_delautobonus_post;
+struct HPMHookPoint *HP_pc_bonus_pre;
+struct HPMHookPoint *HP_pc_bonus_post;
+struct HPMHookPoint *HP_pc_bonus2_pre;
+struct HPMHookPoint *HP_pc_bonus2_post;
+struct HPMHookPoint *HP_pc_bonus3_pre;
+struct HPMHookPoint *HP_pc_bonus3_post;
+struct HPMHookPoint *HP_pc_bonus4_pre;
+struct HPMHookPoint *HP_pc_bonus4_post;
+struct HPMHookPoint *HP_pc_bonus5_pre;
+struct HPMHookPoint *HP_pc_bonus5_post;
+struct HPMHookPoint *HP_pc_skill_pre;
+struct HPMHookPoint *HP_pc_skill_post;
+struct HPMHookPoint *HP_pc_insert_card_pre;
+struct HPMHookPoint *HP_pc_insert_card_post;
+struct HPMHookPoint *HP_pc_steal_item_pre;
+struct HPMHookPoint *HP_pc_steal_item_post;
+struct HPMHookPoint *HP_pc_steal_coin_pre;
+struct HPMHookPoint *HP_pc_steal_coin_post;
+struct HPMHookPoint *HP_pc_modifybuyvalue_pre;
+struct HPMHookPoint *HP_pc_modifybuyvalue_post;
+struct HPMHookPoint *HP_pc_modifysellvalue_pre;
+struct HPMHookPoint *HP_pc_modifysellvalue_post;
+struct HPMHookPoint *HP_pc_follow_pre;
+struct HPMHookPoint *HP_pc_follow_post;
+struct HPMHookPoint *HP_pc_stop_following_pre;
+struct HPMHookPoint *HP_pc_stop_following_post;
+struct HPMHookPoint *HP_pc_maxbaselv_pre;
+struct HPMHookPoint *HP_pc_maxbaselv_post;
+struct HPMHookPoint *HP_pc_maxjoblv_pre;
+struct HPMHookPoint *HP_pc_maxjoblv_post;
+struct HPMHookPoint *HP_pc_checkbaselevelup_pre;
+struct HPMHookPoint *HP_pc_checkbaselevelup_post;
+struct HPMHookPoint *HP_pc_checkjoblevelup_pre;
+struct HPMHookPoint *HP_pc_checkjoblevelup_post;
+struct HPMHookPoint *HP_pc_gainexp_pre;
+struct HPMHookPoint *HP_pc_gainexp_post;
+struct HPMHookPoint *HP_pc_nextbaseexp_pre;
+struct HPMHookPoint *HP_pc_nextbaseexp_post;
+struct HPMHookPoint *HP_pc_thisbaseexp_pre;
+struct HPMHookPoint *HP_pc_thisbaseexp_post;
+struct HPMHookPoint *HP_pc_nextjobexp_pre;
+struct HPMHookPoint *HP_pc_nextjobexp_post;
+struct HPMHookPoint *HP_pc_thisjobexp_pre;
+struct HPMHookPoint *HP_pc_thisjobexp_post;
+struct HPMHookPoint *HP_pc_gets_status_point_pre;
+struct HPMHookPoint *HP_pc_gets_status_point_post;
+struct HPMHookPoint *HP_pc_need_status_point_pre;
+struct HPMHookPoint *HP_pc_need_status_point_post;
+struct HPMHookPoint *HP_pc_statusup_pre;
+struct HPMHookPoint *HP_pc_statusup_post;
+struct HPMHookPoint *HP_pc_statusup2_pre;
+struct HPMHookPoint *HP_pc_statusup2_post;
+struct HPMHookPoint *HP_pc_skillup_pre;
+struct HPMHookPoint *HP_pc_skillup_post;
+struct HPMHookPoint *HP_pc_allskillup_pre;
+struct HPMHookPoint *HP_pc_allskillup_post;
+struct HPMHookPoint *HP_pc_resetlvl_pre;
+struct HPMHookPoint *HP_pc_resetlvl_post;
+struct HPMHookPoint *HP_pc_resetstate_pre;
+struct HPMHookPoint *HP_pc_resetstate_post;
+struct HPMHookPoint *HP_pc_resetskill_pre;
+struct HPMHookPoint *HP_pc_resetskill_post;
+struct HPMHookPoint *HP_pc_resetfeel_pre;
+struct HPMHookPoint *HP_pc_resetfeel_post;
+struct HPMHookPoint *HP_pc_resethate_pre;
+struct HPMHookPoint *HP_pc_resethate_post;
+struct HPMHookPoint *HP_pc_equipitem_pre;
+struct HPMHookPoint *HP_pc_equipitem_post;
+struct HPMHookPoint *HP_pc_unequipitem_pre;
+struct HPMHookPoint *HP_pc_unequipitem_post;
+struct HPMHookPoint *HP_pc_checkitem_pre;
+struct HPMHookPoint *HP_pc_checkitem_post;
+struct HPMHookPoint *HP_pc_useitem_pre;
+struct HPMHookPoint *HP_pc_useitem_post;
+struct HPMHookPoint *HP_pc_skillatk_bonus_pre;
+struct HPMHookPoint *HP_pc_skillatk_bonus_post;
+struct HPMHookPoint *HP_pc_skillheal_bonus_pre;
+struct HPMHookPoint *HP_pc_skillheal_bonus_post;
+struct HPMHookPoint *HP_pc_skillheal2_bonus_pre;
+struct HPMHookPoint *HP_pc_skillheal2_bonus_post;
+struct HPMHookPoint *HP_pc_damage_pre;
+struct HPMHookPoint *HP_pc_damage_post;
+struct HPMHookPoint *HP_pc_dead_pre;
+struct HPMHookPoint *HP_pc_dead_post;
+struct HPMHookPoint *HP_pc_revive_pre;
+struct HPMHookPoint *HP_pc_revive_post;
+struct HPMHookPoint *HP_pc_heal_pre;
+struct HPMHookPoint *HP_pc_heal_post;
+struct HPMHookPoint *HP_pc_itemheal_pre;
+struct HPMHookPoint *HP_pc_itemheal_post;
+struct HPMHookPoint *HP_pc_percentheal_pre;
+struct HPMHookPoint *HP_pc_percentheal_post;
+struct HPMHookPoint *HP_pc_jobchange_pre;
+struct HPMHookPoint *HP_pc_jobchange_post;
+struct HPMHookPoint *HP_pc_setoption_pre;
+struct HPMHookPoint *HP_pc_setoption_post;
+struct HPMHookPoint *HP_pc_setcart_pre;
+struct HPMHookPoint *HP_pc_setcart_post;
+struct HPMHookPoint *HP_pc_setfalcon_pre;
+struct HPMHookPoint *HP_pc_setfalcon_post;
+struct HPMHookPoint *HP_pc_setriding_pre;
+struct HPMHookPoint *HP_pc_setriding_post;
+struct HPMHookPoint *HP_pc_setmadogear_pre;
+struct HPMHookPoint *HP_pc_setmadogear_post;
+struct HPMHookPoint *HP_pc_changelook_pre;
+struct HPMHookPoint *HP_pc_changelook_post;
+struct HPMHookPoint *HP_pc_equiplookall_pre;
+struct HPMHookPoint *HP_pc_equiplookall_post;
+struct HPMHookPoint *HP_pc_readparam_pre;
+struct HPMHookPoint *HP_pc_readparam_post;
+struct HPMHookPoint *HP_pc_setparam_pre;
+struct HPMHookPoint *HP_pc_setparam_post;
+struct HPMHookPoint *HP_pc_readreg_pre;
+struct HPMHookPoint *HP_pc_readreg_post;
+struct HPMHookPoint *HP_pc_setreg_pre;
+struct HPMHookPoint *HP_pc_setreg_post;
+struct HPMHookPoint *HP_pc_readregstr_pre;
+struct HPMHookPoint *HP_pc_readregstr_post;
+struct HPMHookPoint *HP_pc_setregstr_pre;
+struct HPMHookPoint *HP_pc_setregstr_post;
+struct HPMHookPoint *HP_pc_readregistry_pre;
+struct HPMHookPoint *HP_pc_readregistry_post;
+struct HPMHookPoint *HP_pc_setregistry_pre;
+struct HPMHookPoint *HP_pc_setregistry_post;
+struct HPMHookPoint *HP_pc_readregistry_str_pre;
+struct HPMHookPoint *HP_pc_readregistry_str_post;
+struct HPMHookPoint *HP_pc_setregistry_str_pre;
+struct HPMHookPoint *HP_pc_setregistry_str_post;
+struct HPMHookPoint *HP_pc_addeventtimer_pre;
+struct HPMHookPoint *HP_pc_addeventtimer_post;
+struct HPMHookPoint *HP_pc_deleventtimer_pre;
+struct HPMHookPoint *HP_pc_deleventtimer_post;
+struct HPMHookPoint *HP_pc_cleareventtimer_pre;
+struct HPMHookPoint *HP_pc_cleareventtimer_post;
+struct HPMHookPoint *HP_pc_addeventtimercount_pre;
+struct HPMHookPoint *HP_pc_addeventtimercount_post;
+struct HPMHookPoint *HP_pc_calc_pvprank_pre;
+struct HPMHookPoint *HP_pc_calc_pvprank_post;
+struct HPMHookPoint *HP_pc_calc_pvprank_timer_pre;
+struct HPMHookPoint *HP_pc_calc_pvprank_timer_post;
+struct HPMHookPoint *HP_pc_ismarried_pre;
+struct HPMHookPoint *HP_pc_ismarried_post;
+struct HPMHookPoint *HP_pc_marriage_pre;
+struct HPMHookPoint *HP_pc_marriage_post;
+struct HPMHookPoint *HP_pc_divorce_pre;
+struct HPMHookPoint *HP_pc_divorce_post;
+struct HPMHookPoint *HP_pc_get_partner_pre;
+struct HPMHookPoint *HP_pc_get_partner_post;
+struct HPMHookPoint *HP_pc_get_father_pre;
+struct HPMHookPoint *HP_pc_get_father_post;
+struct HPMHookPoint *HP_pc_get_mother_pre;
+struct HPMHookPoint *HP_pc_get_mother_post;
+struct HPMHookPoint *HP_pc_get_child_pre;
+struct HPMHookPoint *HP_pc_get_child_post;
+struct HPMHookPoint *HP_pc_bleeding_pre;
+struct HPMHookPoint *HP_pc_bleeding_post;
+struct HPMHookPoint *HP_pc_regen_pre;
+struct HPMHookPoint *HP_pc_regen_post;
+struct HPMHookPoint *HP_pc_setstand_pre;
+struct HPMHookPoint *HP_pc_setstand_post;
+struct HPMHookPoint *HP_pc_candrop_pre;
+struct HPMHookPoint *HP_pc_candrop_post;
+struct HPMHookPoint *HP_pc_jobid2mapid_pre;
+struct HPMHookPoint *HP_pc_jobid2mapid_post;
+struct HPMHookPoint *HP_pc_mapid2jobid_pre;
+struct HPMHookPoint *HP_pc_mapid2jobid_post;
+struct HPMHookPoint *HP_pc_job_name_pre;
+struct HPMHookPoint *HP_pc_job_name_post;
+struct HPMHookPoint *HP_pc_setinvincibletimer_pre;
+struct HPMHookPoint *HP_pc_setinvincibletimer_post;
+struct HPMHookPoint *HP_pc_delinvincibletimer_pre;
+struct HPMHookPoint *HP_pc_delinvincibletimer_post;
+struct HPMHookPoint *HP_pc_addspiritball_pre;
+struct HPMHookPoint *HP_pc_addspiritball_post;
+struct HPMHookPoint *HP_pc_delspiritball_pre;
+struct HPMHookPoint *HP_pc_delspiritball_post;
+struct HPMHookPoint *HP_pc_addfame_pre;
+struct HPMHookPoint *HP_pc_addfame_post;
+struct HPMHookPoint *HP_pc_famerank_pre;
+struct HPMHookPoint *HP_pc_famerank_post;
+struct HPMHookPoint *HP_pc_set_hate_mob_pre;
+struct HPMHookPoint *HP_pc_set_hate_mob_post;
+struct HPMHookPoint *HP_pc_readdb_pre;
+struct HPMHookPoint *HP_pc_readdb_post;
+struct HPMHookPoint *HP_pc_map_day_timer_pre;
+struct HPMHookPoint *HP_pc_map_day_timer_post;
+struct HPMHookPoint *HP_pc_map_night_timer_pre;
+struct HPMHookPoint *HP_pc_map_night_timer_post;
+struct HPMHookPoint *HP_pc_inventory_rentals_pre;
+struct HPMHookPoint *HP_pc_inventory_rentals_post;
+struct HPMHookPoint *HP_pc_inventory_rental_clear_pre;
+struct HPMHookPoint *HP_pc_inventory_rental_clear_post;
+struct HPMHookPoint *HP_pc_inventory_rental_add_pre;
+struct HPMHookPoint *HP_pc_inventory_rental_add_post;
+struct HPMHookPoint *HP_pc_disguise_pre;
+struct HPMHookPoint *HP_pc_disguise_post;
+struct HPMHookPoint *HP_pc_isautolooting_pre;
+struct HPMHookPoint *HP_pc_isautolooting_post;
+struct HPMHookPoint *HP_pc_overheat_pre;
+struct HPMHookPoint *HP_pc_overheat_post;
+struct HPMHookPoint *HP_pc_banding_pre;
+struct HPMHookPoint *HP_pc_banding_post;
+struct HPMHookPoint *HP_pc_itemcd_do_pre;
+struct HPMHookPoint *HP_pc_itemcd_do_post;
+struct HPMHookPoint *HP_pc_load_combo_pre;
+struct HPMHookPoint *HP_pc_load_combo_post;
+struct HPMHookPoint *HP_pc_add_charm_pre;
+struct HPMHookPoint *HP_pc_add_charm_post;
+struct HPMHookPoint *HP_pc_del_charm_pre;
+struct HPMHookPoint *HP_pc_del_charm_post;
+struct HPMHookPoint *HP_pc_baselevelchanged_pre;
+struct HPMHookPoint *HP_pc_baselevelchanged_post;
+struct HPMHookPoint *HP_pc_level_penalty_mod_pre;
+struct HPMHookPoint *HP_pc_level_penalty_mod_post;
+struct HPMHookPoint *HP_pc_calc_skillpoint_pre;
+struct HPMHookPoint *HP_pc_calc_skillpoint_post;
+struct HPMHookPoint *HP_pc_invincible_timer_pre;
+struct HPMHookPoint *HP_pc_invincible_timer_post;
+struct HPMHookPoint *HP_pc_spiritball_timer_pre;
+struct HPMHookPoint *HP_pc_spiritball_timer_post;
+struct HPMHookPoint *HP_pc_check_banding_pre;
+struct HPMHookPoint *HP_pc_check_banding_post;
+struct HPMHookPoint *HP_pc_inventory_rental_end_pre;
+struct HPMHookPoint *HP_pc_inventory_rental_end_post;
+struct HPMHookPoint *HP_pc_check_skilltree_pre;
+struct HPMHookPoint *HP_pc_check_skilltree_post;
+struct HPMHookPoint *HP_pc_bonus_autospell_pre;
+struct HPMHookPoint *HP_pc_bonus_autospell_post;
+struct HPMHookPoint *HP_pc_bonus_autospell_onskill_pre;
+struct HPMHookPoint *HP_pc_bonus_autospell_onskill_post;
+struct HPMHookPoint *HP_pc_bonus_addeff_pre;
+struct HPMHookPoint *HP_pc_bonus_addeff_post;
+struct HPMHookPoint *HP_pc_bonus_addeff_onskill_pre;
+struct HPMHookPoint *HP_pc_bonus_addeff_onskill_post;
+struct HPMHookPoint *HP_pc_bonus_item_drop_pre;
+struct HPMHookPoint *HP_pc_bonus_item_drop_post;
+struct HPMHookPoint *HP_pc_calcexp_pre;
+struct HPMHookPoint *HP_pc_calcexp_post;
+struct HPMHookPoint *HP_pc_respawn_timer_pre;
+struct HPMHookPoint *HP_pc_respawn_timer_post;
+struct HPMHookPoint *HP_pc_jobchange_killclone_pre;
+struct HPMHookPoint *HP_pc_jobchange_killclone_post;
+struct HPMHookPoint *HP_pc_getstat_pre;
+struct HPMHookPoint *HP_pc_getstat_post;
+struct HPMHookPoint *HP_pc_setstat_pre;
+struct HPMHookPoint *HP_pc_setstat_post;
+struct HPMHookPoint *HP_pc_eventtimer_pre;
+struct HPMHookPoint *HP_pc_eventtimer_post;
+struct HPMHookPoint *HP_pc_daynight_timer_sub_pre;
+struct HPMHookPoint *HP_pc_daynight_timer_sub_post;
+struct HPMHookPoint *HP_pc_charm_timer_pre;
+struct HPMHookPoint *HP_pc_charm_timer_post;
+struct HPMHookPoint *HP_pc_readdb_levelpenalty_pre;
+struct HPMHookPoint *HP_pc_readdb_levelpenalty_post;
+struct HPMHookPoint *HP_pc_autosave_pre;
+struct HPMHookPoint *HP_pc_autosave_post;
+struct HPMHookPoint *HP_pc_follow_timer_pre;
+struct HPMHookPoint *HP_pc_follow_timer_post;
+struct HPMHookPoint *HP_pc_read_skill_tree_pre;
+struct HPMHookPoint *HP_pc_read_skill_tree_post;
+struct HPMHookPoint *HP_pc_isUseitem_pre;
+struct HPMHookPoint *HP_pc_isUseitem_post;
+struct HPMHookPoint *HP_pc_show_steal_pre;
+struct HPMHookPoint *HP_pc_show_steal_post;
+struct HPMHookPoint *HP_pc_checkcombo_pre;
+struct HPMHookPoint *HP_pc_checkcombo_post;
+struct HPMHookPoint *HP_pc_calcweapontype_pre;
+struct HPMHookPoint *HP_pc_calcweapontype_post;
+struct HPMHookPoint *HP_pc_removecombo_pre;
+struct HPMHookPoint *HP_pc_removecombo_post;
+struct HPMHookPoint *HP_pet_init_pre;
+struct HPMHookPoint *HP_pet_init_post;
+struct HPMHookPoint *HP_pet_final_pre;
+struct HPMHookPoint *HP_pet_final_post;
+struct HPMHookPoint *HP_pet_hungry_val_pre;
+struct HPMHookPoint *HP_pet_hungry_val_post;
+struct HPMHookPoint *HP_pet_set_intimate_pre;
+struct HPMHookPoint *HP_pet_set_intimate_post;
+struct HPMHookPoint *HP_pet_create_egg_pre;
+struct HPMHookPoint *HP_pet_create_egg_post;
+struct HPMHookPoint *HP_pet_unlocktarget_pre;
+struct HPMHookPoint *HP_pet_unlocktarget_post;
+struct HPMHookPoint *HP_pet_attackskill_pre;
+struct HPMHookPoint *HP_pet_attackskill_post;
+struct HPMHookPoint *HP_pet_target_check_pre;
+struct HPMHookPoint *HP_pet_target_check_post;
+struct HPMHookPoint *HP_pet_sc_check_pre;
+struct HPMHookPoint *HP_pet_sc_check_post;
+struct HPMHookPoint *HP_pet_hungry_pre;
+struct HPMHookPoint *HP_pet_hungry_post;
+struct HPMHookPoint *HP_pet_search_petDB_index_pre;
+struct HPMHookPoint *HP_pet_search_petDB_index_post;
+struct HPMHookPoint *HP_pet_hungry_timer_delete_pre;
+struct HPMHookPoint *HP_pet_hungry_timer_delete_post;
+struct HPMHookPoint *HP_pet_performance_pre;
+struct HPMHookPoint *HP_pet_performance_post;
+struct HPMHookPoint *HP_pet_return_egg_pre;
+struct HPMHookPoint *HP_pet_return_egg_post;
+struct HPMHookPoint *HP_pet_data_init_pre;
+struct HPMHookPoint *HP_pet_data_init_post;
+struct HPMHookPoint *HP_pet_birth_process_pre;
+struct HPMHookPoint *HP_pet_birth_process_post;
+struct HPMHookPoint *HP_pet_recv_petdata_pre;
+struct HPMHookPoint *HP_pet_recv_petdata_post;
+struct HPMHookPoint *HP_pet_select_egg_pre;
+struct HPMHookPoint *HP_pet_select_egg_post;
+struct HPMHookPoint *HP_pet_catch_process1_pre;
+struct HPMHookPoint *HP_pet_catch_process1_post;
+struct HPMHookPoint *HP_pet_catch_process2_pre;
+struct HPMHookPoint *HP_pet_catch_process2_post;
+struct HPMHookPoint *HP_pet_get_egg_pre;
+struct HPMHookPoint *HP_pet_get_egg_post;
+struct HPMHookPoint *HP_pet_unequipitem_pre;
+struct HPMHookPoint *HP_pet_unequipitem_post;
+struct HPMHookPoint *HP_pet_food_pre;
+struct HPMHookPoint *HP_pet_food_post;
+struct HPMHookPoint *HP_pet_ai_sub_hard_lootsearch_pre;
+struct HPMHookPoint *HP_pet_ai_sub_hard_lootsearch_post;
+struct HPMHookPoint *HP_pet_menu_pre;
+struct HPMHookPoint *HP_pet_menu_post;
+struct HPMHookPoint *HP_pet_change_name_pre;
+struct HPMHookPoint *HP_pet_change_name_post;
+struct HPMHookPoint *HP_pet_change_name_ack_pre;
+struct HPMHookPoint *HP_pet_change_name_ack_post;
+struct HPMHookPoint *HP_pet_equipitem_pre;
+struct HPMHookPoint *HP_pet_equipitem_post;
+struct HPMHookPoint *HP_pet_randomwalk_pre;
+struct HPMHookPoint *HP_pet_randomwalk_post;
+struct HPMHookPoint *HP_pet_ai_sub_hard_pre;
+struct HPMHookPoint *HP_pet_ai_sub_hard_post;
+struct HPMHookPoint *HP_pet_ai_sub_foreachclient_pre;
+struct HPMHookPoint *HP_pet_ai_sub_foreachclient_post;
+struct HPMHookPoint *HP_pet_ai_hard_pre;
+struct HPMHookPoint *HP_pet_ai_hard_post;
+struct HPMHookPoint *HP_pet_delay_item_drop_pre;
+struct HPMHookPoint *HP_pet_delay_item_drop_post;
+struct HPMHookPoint *HP_pet_lootitem_drop_pre;
+struct HPMHookPoint *HP_pet_lootitem_drop_post;
+struct HPMHookPoint *HP_pet_skill_bonus_timer_pre;
+struct HPMHookPoint *HP_pet_skill_bonus_timer_post;
+struct HPMHookPoint *HP_pet_recovery_timer_pre;
+struct HPMHookPoint *HP_pet_recovery_timer_post;
+struct HPMHookPoint *HP_pet_heal_timer_pre;
+struct HPMHookPoint *HP_pet_heal_timer_post;
+struct HPMHookPoint *HP_pet_skill_support_timer_pre;
+struct HPMHookPoint *HP_pet_skill_support_timer_post;
+struct HPMHookPoint *HP_pet_read_db_pre;
+struct HPMHookPoint *HP_pet_read_db_post;
+struct HPMHookPoint *HP_quest_init_pre;
+struct HPMHookPoint *HP_quest_init_post;
+struct HPMHookPoint *HP_quest_reload_pre;
+struct HPMHookPoint *HP_quest_reload_post;
+struct HPMHookPoint *HP_quest_search_db_pre;
+struct HPMHookPoint *HP_quest_search_db_post;
+struct HPMHookPoint *HP_quest_pc_login_pre;
+struct HPMHookPoint *HP_quest_pc_login_post;
+struct HPMHookPoint *HP_quest_add_pre;
+struct HPMHookPoint *HP_quest_add_post;
+struct HPMHookPoint *HP_quest_change_pre;
+struct HPMHookPoint *HP_quest_change_post;
+struct HPMHookPoint *HP_quest_delete_pre;
+struct HPMHookPoint *HP_quest_delete_post;
+struct HPMHookPoint *HP_quest_update_objective_sub_pre;
+struct HPMHookPoint *HP_quest_update_objective_sub_post;
+struct HPMHookPoint *HP_quest_update_objective_pre;
+struct HPMHookPoint *HP_quest_update_objective_post;
+struct HPMHookPoint *HP_quest_update_status_pre;
+struct HPMHookPoint *HP_quest_update_status_post;
+struct HPMHookPoint *HP_quest_check_pre;
+struct HPMHookPoint *HP_quest_check_post;
+struct HPMHookPoint *HP_quest_read_db_pre;
+struct HPMHookPoint *HP_quest_read_db_post;
+struct HPMHookPoint *HP_script_init_pre;
+struct HPMHookPoint *HP_script_init_post;
+struct HPMHookPoint *HP_script_final_pre;
+struct HPMHookPoint *HP_script_final_post;
+struct HPMHookPoint *HP_script_reload_pre;
+struct HPMHookPoint *HP_script_reload_post;
+struct HPMHookPoint *HP_script_parse_pre;
+struct HPMHookPoint *HP_script_parse_post;
+struct HPMHookPoint *HP_script_parse_builtin_pre;
+struct HPMHookPoint *HP_script_parse_builtin_post;
+struct HPMHookPoint *HP_script_parse_subexpr_pre;
+struct HPMHookPoint *HP_script_parse_subexpr_post;
+struct HPMHookPoint *HP_script_skip_space_pre;
+struct HPMHookPoint *HP_script_skip_space_post;
+struct HPMHookPoint *HP_script_error_pre;
+struct HPMHookPoint *HP_script_error_post;
+struct HPMHookPoint *HP_script_warning_pre;
+struct HPMHookPoint *HP_script_warning_post;
+struct HPMHookPoint *HP_script_addScript_pre;
+struct HPMHookPoint *HP_script_addScript_post;
+struct HPMHookPoint *HP_script_conv_num_pre;
+struct HPMHookPoint *HP_script_conv_num_post;
+struct HPMHookPoint *HP_script_conv_str_pre;
+struct HPMHookPoint *HP_script_conv_str_post;
+struct HPMHookPoint *HP_script_rid2sd_pre;
+struct HPMHookPoint *HP_script_rid2sd_post;
+struct HPMHookPoint *HP_script_detach_rid_pre;
+struct HPMHookPoint *HP_script_detach_rid_post;
+struct HPMHookPoint *HP_script_push_val_pre;
+struct HPMHookPoint *HP_script_push_val_post;
+struct HPMHookPoint *HP_script_get_val_pre;
+struct HPMHookPoint *HP_script_get_val_post;
+struct HPMHookPoint *HP_script_get_val2_pre;
+struct HPMHookPoint *HP_script_get_val2_post;
+struct HPMHookPoint *HP_script_push_str_pre;
+struct HPMHookPoint *HP_script_push_str_post;
+struct HPMHookPoint *HP_script_push_copy_pre;
+struct HPMHookPoint *HP_script_push_copy_post;
+struct HPMHookPoint *HP_script_pop_stack_pre;
+struct HPMHookPoint *HP_script_pop_stack_post;
+struct HPMHookPoint *HP_script_set_constant_pre;
+struct HPMHookPoint *HP_script_set_constant_post;
+struct HPMHookPoint *HP_script_set_constant2_pre;
+struct HPMHookPoint *HP_script_set_constant2_post;
+struct HPMHookPoint *HP_script_set_constant_force_pre;
+struct HPMHookPoint *HP_script_set_constant_force_post;
+struct HPMHookPoint *HP_script_get_constant_pre;
+struct HPMHookPoint *HP_script_get_constant_post;
+struct HPMHookPoint *HP_script_label_add_pre;
+struct HPMHookPoint *HP_script_label_add_post;
+struct HPMHookPoint *HP_script_run_pre;
+struct HPMHookPoint *HP_script_run_post;
+struct HPMHookPoint *HP_script_run_main_pre;
+struct HPMHookPoint *HP_script_run_main_post;
+struct HPMHookPoint *HP_script_run_timer_pre;
+struct HPMHookPoint *HP_script_run_timer_post;
+struct HPMHookPoint *HP_script_set_var_pre;
+struct HPMHookPoint *HP_script_set_var_post;
+struct HPMHookPoint *HP_script_stop_instances_pre;
+struct HPMHookPoint *HP_script_stop_instances_post;
+struct HPMHookPoint *HP_script_free_code_pre;
+struct HPMHookPoint *HP_script_free_code_post;
+struct HPMHookPoint *HP_script_free_vars_pre;
+struct HPMHookPoint *HP_script_free_vars_post;
+struct HPMHookPoint *HP_script_alloc_state_pre;
+struct HPMHookPoint *HP_script_alloc_state_post;
+struct HPMHookPoint *HP_script_free_state_pre;
+struct HPMHookPoint *HP_script_free_state_post;
+struct HPMHookPoint *HP_script_run_autobonus_pre;
+struct HPMHookPoint *HP_script_run_autobonus_post;
+struct HPMHookPoint *HP_script_cleararray_pc_pre;
+struct HPMHookPoint *HP_script_cleararray_pc_post;
+struct HPMHookPoint *HP_script_setarray_pc_pre;
+struct HPMHookPoint *HP_script_setarray_pc_post;
+struct HPMHookPoint *HP_script_config_read_pre;
+struct HPMHookPoint *HP_script_config_read_post;
+struct HPMHookPoint *HP_script_add_str_pre;
+struct HPMHookPoint *HP_script_add_str_post;
+struct HPMHookPoint *HP_script_get_str_pre;
+struct HPMHookPoint *HP_script_get_str_post;
+struct HPMHookPoint *HP_script_search_str_pre;
+struct HPMHookPoint *HP_script_search_str_post;
+struct HPMHookPoint *HP_script_setd_sub_pre;
+struct HPMHookPoint *HP_script_setd_sub_post;
+struct HPMHookPoint *HP_script_attach_state_pre;
+struct HPMHookPoint *HP_script_attach_state_post;
+struct HPMHookPoint *HP_script_queue_pre;
+struct HPMHookPoint *HP_script_queue_post;
+struct HPMHookPoint *HP_script_queue_add_pre;
+struct HPMHookPoint *HP_script_queue_add_post;
+struct HPMHookPoint *HP_script_queue_del_pre;
+struct HPMHookPoint *HP_script_queue_del_post;
+struct HPMHookPoint *HP_script_queue_remove_pre;
+struct HPMHookPoint *HP_script_queue_remove_post;
+struct HPMHookPoint *HP_script_queue_create_pre;
+struct HPMHookPoint *HP_script_queue_create_post;
+struct HPMHookPoint *HP_script_queue_clear_pre;
+struct HPMHookPoint *HP_script_queue_clear_post;
+struct HPMHookPoint *HP_script_parse_curly_close_pre;
+struct HPMHookPoint *HP_script_parse_curly_close_post;
+struct HPMHookPoint *HP_script_parse_syntax_close_pre;
+struct HPMHookPoint *HP_script_parse_syntax_close_post;
+struct HPMHookPoint *HP_script_parse_syntax_close_sub_pre;
+struct HPMHookPoint *HP_script_parse_syntax_close_sub_post;
+struct HPMHookPoint *HP_script_parse_syntax_pre;
+struct HPMHookPoint *HP_script_parse_syntax_post;
+struct HPMHookPoint *HP_script_get_com_pre;
+struct HPMHookPoint *HP_script_get_com_post;
+struct HPMHookPoint *HP_script_get_num_pre;
+struct HPMHookPoint *HP_script_get_num_post;
+struct HPMHookPoint *HP_script_op2name_pre;
+struct HPMHookPoint *HP_script_op2name_post;
+struct HPMHookPoint *HP_script_reportsrc_pre;
+struct HPMHookPoint *HP_script_reportsrc_post;
+struct HPMHookPoint *HP_script_reportdata_pre;
+struct HPMHookPoint *HP_script_reportdata_post;
+struct HPMHookPoint *HP_script_reportfunc_pre;
+struct HPMHookPoint *HP_script_reportfunc_post;
+struct HPMHookPoint *HP_script_disp_error_message2_pre;
+struct HPMHookPoint *HP_script_disp_error_message2_post;
+struct HPMHookPoint *HP_script_disp_warning_message_pre;
+struct HPMHookPoint *HP_script_disp_warning_message_post;
+struct HPMHookPoint *HP_script_check_event_pre;
+struct HPMHookPoint *HP_script_check_event_post;
+struct HPMHookPoint *HP_script_calc_hash_pre;
+struct HPMHookPoint *HP_script_calc_hash_post;
+struct HPMHookPoint *HP_script_addb_pre;
+struct HPMHookPoint *HP_script_addb_post;
+struct HPMHookPoint *HP_script_addc_pre;
+struct HPMHookPoint *HP_script_addc_post;
+struct HPMHookPoint *HP_script_addi_pre;
+struct HPMHookPoint *HP_script_addi_post;
+struct HPMHookPoint *HP_script_addl_pre;
+struct HPMHookPoint *HP_script_addl_post;
+struct HPMHookPoint *HP_script_set_label_pre;
+struct HPMHookPoint *HP_script_set_label_post;
+struct HPMHookPoint *HP_script_skip_word_pre;
+struct HPMHookPoint *HP_script_skip_word_post;
+struct HPMHookPoint *HP_script_add_word_pre;
+struct HPMHookPoint *HP_script_add_word_post;
+struct HPMHookPoint *HP_script_parse_callfunc_pre;
+struct HPMHookPoint *HP_script_parse_callfunc_post;
+struct HPMHookPoint *HP_script_parse_nextline_pre;
+struct HPMHookPoint *HP_script_parse_nextline_post;
+struct HPMHookPoint *HP_script_parse_variable_pre;
+struct HPMHookPoint *HP_script_parse_variable_post;
+struct HPMHookPoint *HP_script_parse_simpleexpr_pre;
+struct HPMHookPoint *HP_script_parse_simpleexpr_post;
+struct HPMHookPoint *HP_script_parse_expr_pre;
+struct HPMHookPoint *HP_script_parse_expr_post;
+struct HPMHookPoint *HP_script_parse_line_pre;
+struct HPMHookPoint *HP_script_parse_line_post;
+struct HPMHookPoint *HP_script_read_constdb_pre;
+struct HPMHookPoint *HP_script_read_constdb_post;
+struct HPMHookPoint *HP_script_print_line_pre;
+struct HPMHookPoint *HP_script_print_line_post;
+struct HPMHookPoint *HP_script_errorwarning_sub_pre;
+struct HPMHookPoint *HP_script_errorwarning_sub_post;
+struct HPMHookPoint *HP_script_set_reg_pre;
+struct HPMHookPoint *HP_script_set_reg_post;
+struct HPMHookPoint *HP_script_stack_expand_pre;
+struct HPMHookPoint *HP_script_stack_expand_post;
+struct HPMHookPoint *HP_script_push_retinfo_pre;
+struct HPMHookPoint *HP_script_push_retinfo_post;
+struct HPMHookPoint *HP_script_pop_val_pre;
+struct HPMHookPoint *HP_script_pop_val_post;
+struct HPMHookPoint *HP_script_op_3_pre;
+struct HPMHookPoint *HP_script_op_3_post;
+struct HPMHookPoint *HP_script_op_2str_pre;
+struct HPMHookPoint *HP_script_op_2str_post;
+struct HPMHookPoint *HP_script_op_2num_pre;
+struct HPMHookPoint *HP_script_op_2num_post;
+struct HPMHookPoint *HP_script_op_2_pre;
+struct HPMHookPoint *HP_script_op_2_post;
+struct HPMHookPoint *HP_script_op_1_pre;
+struct HPMHookPoint *HP_script_op_1_post;
+struct HPMHookPoint *HP_script_check_buildin_argtype_pre;
+struct HPMHookPoint *HP_script_check_buildin_argtype_post;
+struct HPMHookPoint *HP_script_detach_state_pre;
+struct HPMHookPoint *HP_script_detach_state_post;
+struct HPMHookPoint *HP_script_db_free_code_sub_pre;
+struct HPMHookPoint *HP_script_db_free_code_sub_post;
+struct HPMHookPoint *HP_script_add_autobonus_pre;
+struct HPMHookPoint *HP_script_add_autobonus_post;
+struct HPMHookPoint *HP_script_menu_countoptions_pre;
+struct HPMHookPoint *HP_script_menu_countoptions_post;
+struct HPMHookPoint *HP_script_buildin_areawarp_sub_pre;
+struct HPMHookPoint *HP_script_buildin_areawarp_sub_post;
+struct HPMHookPoint *HP_script_buildin_areapercentheal_sub_pre;
+struct HPMHookPoint *HP_script_buildin_areapercentheal_sub_post;
+struct HPMHookPoint *HP_script_getarraysize_pre;
+struct HPMHookPoint *HP_script_getarraysize_post;
+struct HPMHookPoint *HP_script_buildin_delitem_delete_pre;
+struct HPMHookPoint *HP_script_buildin_delitem_delete_post;
+struct HPMHookPoint *HP_script_buildin_delitem_search_pre;
+struct HPMHookPoint *HP_script_buildin_delitem_search_post;
+struct HPMHookPoint *HP_script_buildin_killmonster_sub_strip_pre;
+struct HPMHookPoint *HP_script_buildin_killmonster_sub_strip_post;
+struct HPMHookPoint *HP_script_buildin_killmonster_sub_pre;
+struct HPMHookPoint *HP_script_buildin_killmonster_sub_post;
+struct HPMHookPoint *HP_script_buildin_killmonsterall_sub_strip_pre;
+struct HPMHookPoint *HP_script_buildin_killmonsterall_sub_strip_post;
+struct HPMHookPoint *HP_script_buildin_killmonsterall_sub_pre;
+struct HPMHookPoint *HP_script_buildin_killmonsterall_sub_post;
+struct HPMHookPoint *HP_script_buildin_announce_sub_pre;
+struct HPMHookPoint *HP_script_buildin_announce_sub_post;
+struct HPMHookPoint *HP_script_buildin_getareausers_sub_pre;
+struct HPMHookPoint *HP_script_buildin_getareausers_sub_post;
+struct HPMHookPoint *HP_script_buildin_getareadropitem_sub_pre;
+struct HPMHookPoint *HP_script_buildin_getareadropitem_sub_post;
+struct HPMHookPoint *HP_script_mapflag_pvp_sub_pre;
+struct HPMHookPoint *HP_script_mapflag_pvp_sub_post;
+struct HPMHookPoint *HP_script_buildin_pvpoff_sub_pre;
+struct HPMHookPoint *HP_script_buildin_pvpoff_sub_post;
+struct HPMHookPoint *HP_script_buildin_maprespawnguildid_sub_pc_pre;
+struct HPMHookPoint *HP_script_buildin_maprespawnguildid_sub_pc_post;
+struct HPMHookPoint *HP_script_buildin_maprespawnguildid_sub_mob_pre;
+struct HPMHookPoint *HP_script_buildin_maprespawnguildid_sub_mob_post;
+struct HPMHookPoint *HP_script_buildin_mobcount_sub_pre;
+struct HPMHookPoint *HP_script_buildin_mobcount_sub_post;
+struct HPMHookPoint *HP_script_playBGM_sub_pre;
+struct HPMHookPoint *HP_script_playBGM_sub_post;
+struct HPMHookPoint *HP_script_playBGM_foreachpc_sub_pre;
+struct HPMHookPoint *HP_script_playBGM_foreachpc_sub_post;
+struct HPMHookPoint *HP_script_soundeffect_sub_pre;
+struct HPMHookPoint *HP_script_soundeffect_sub_post;
+struct HPMHookPoint *HP_script_buildin_query_sql_sub_pre;
+struct HPMHookPoint *HP_script_buildin_query_sql_sub_post;
+struct HPMHookPoint *HP_script_axtoi_pre;
+struct HPMHookPoint *HP_script_axtoi_post;
+struct HPMHookPoint *HP_script_buildin_instance_warpall_sub_pre;
+struct HPMHookPoint *HP_script_buildin_instance_warpall_sub_post;
+struct HPMHookPoint *HP_script_buildin_mobuseskill_sub_pre;
+struct HPMHookPoint *HP_script_buildin_mobuseskill_sub_post;
+struct HPMHookPoint *HP_script_cleanfloor_sub_pre;
+struct HPMHookPoint *HP_script_cleanfloor_sub_post;
+struct HPMHookPoint *HP_script_run_func_pre;
+struct HPMHookPoint *HP_script_run_func_post;
+struct HPMHookPoint *HP_searchstore_open_pre;
+struct HPMHookPoint *HP_searchstore_open_post;
+struct HPMHookPoint *HP_searchstore_query_pre;
+struct HPMHookPoint *HP_searchstore_query_post;
+struct HPMHookPoint *HP_searchstore_querynext_pre;
+struct HPMHookPoint *HP_searchstore_querynext_post;
+struct HPMHookPoint *HP_searchstore_next_pre;
+struct HPMHookPoint *HP_searchstore_next_post;
+struct HPMHookPoint *HP_searchstore_clear_pre;
+struct HPMHookPoint *HP_searchstore_clear_post;
+struct HPMHookPoint *HP_searchstore_close_pre;
+struct HPMHookPoint *HP_searchstore_close_post;
+struct HPMHookPoint *HP_searchstore_click_pre;
+struct HPMHookPoint *HP_searchstore_click_post;
+struct HPMHookPoint *HP_searchstore_queryremote_pre;
+struct HPMHookPoint *HP_searchstore_queryremote_post;
+struct HPMHookPoint *HP_searchstore_clearremote_pre;
+struct HPMHookPoint *HP_searchstore_clearremote_post;
+struct HPMHookPoint *HP_searchstore_result_pre;
+struct HPMHookPoint *HP_searchstore_result_post;
+struct HPMHookPoint *HP_skill_init_pre;
+struct HPMHookPoint *HP_skill_init_post;
+struct HPMHookPoint *HP_skill_final_pre;
+struct HPMHookPoint *HP_skill_final_post;
+struct HPMHookPoint *HP_skill_reload_pre;
+struct HPMHookPoint *HP_skill_reload_post;
+struct HPMHookPoint *HP_skill_read_db_pre;
+struct HPMHookPoint *HP_skill_read_db_post;
+struct HPMHookPoint *HP_skill_get_index_pre;
+struct HPMHookPoint *HP_skill_get_index_post;
+struct HPMHookPoint *HP_skill_get_type_pre;
+struct HPMHookPoint *HP_skill_get_type_post;
+struct HPMHookPoint *HP_skill_get_hit_pre;
+struct HPMHookPoint *HP_skill_get_hit_post;
+struct HPMHookPoint *HP_skill_get_inf_pre;
+struct HPMHookPoint *HP_skill_get_inf_post;
+struct HPMHookPoint *HP_skill_get_ele_pre;
+struct HPMHookPoint *HP_skill_get_ele_post;
+struct HPMHookPoint *HP_skill_get_nk_pre;
+struct HPMHookPoint *HP_skill_get_nk_post;
+struct HPMHookPoint *HP_skill_get_max_pre;
+struct HPMHookPoint *HP_skill_get_max_post;
+struct HPMHookPoint *HP_skill_get_range_pre;
+struct HPMHookPoint *HP_skill_get_range_post;
+struct HPMHookPoint *HP_skill_get_range2_pre;
+struct HPMHookPoint *HP_skill_get_range2_post;
+struct HPMHookPoint *HP_skill_get_splash_pre;
+struct HPMHookPoint *HP_skill_get_splash_post;
+struct HPMHookPoint *HP_skill_get_hp_pre;
+struct HPMHookPoint *HP_skill_get_hp_post;
+struct HPMHookPoint *HP_skill_get_mhp_pre;
+struct HPMHookPoint *HP_skill_get_mhp_post;
+struct HPMHookPoint *HP_skill_get_sp_pre;
+struct HPMHookPoint *HP_skill_get_sp_post;
+struct HPMHookPoint *HP_skill_get_state_pre;
+struct HPMHookPoint *HP_skill_get_state_post;
+struct HPMHookPoint *HP_skill_get_spiritball_pre;
+struct HPMHookPoint *HP_skill_get_spiritball_post;
+struct HPMHookPoint *HP_skill_get_zeny_pre;
+struct HPMHookPoint *HP_skill_get_zeny_post;
+struct HPMHookPoint *HP_skill_get_num_pre;
+struct HPMHookPoint *HP_skill_get_num_post;
+struct HPMHookPoint *HP_skill_get_cast_pre;
+struct HPMHookPoint *HP_skill_get_cast_post;
+struct HPMHookPoint *HP_skill_get_delay_pre;
+struct HPMHookPoint *HP_skill_get_delay_post;
+struct HPMHookPoint *HP_skill_get_walkdelay_pre;
+struct HPMHookPoint *HP_skill_get_walkdelay_post;
+struct HPMHookPoint *HP_skill_get_time_pre;
+struct HPMHookPoint *HP_skill_get_time_post;
+struct HPMHookPoint *HP_skill_get_time2_pre;
+struct HPMHookPoint *HP_skill_get_time2_post;
+struct HPMHookPoint *HP_skill_get_castnodex_pre;
+struct HPMHookPoint *HP_skill_get_castnodex_post;
+struct HPMHookPoint *HP_skill_get_delaynodex_pre;
+struct HPMHookPoint *HP_skill_get_delaynodex_post;
+struct HPMHookPoint *HP_skill_get_castdef_pre;
+struct HPMHookPoint *HP_skill_get_castdef_post;
+struct HPMHookPoint *HP_skill_get_weapontype_pre;
+struct HPMHookPoint *HP_skill_get_weapontype_post;
+struct HPMHookPoint *HP_skill_get_ammotype_pre;
+struct HPMHookPoint *HP_skill_get_ammotype_post;
+struct HPMHookPoint *HP_skill_get_ammo_qty_pre;
+struct HPMHookPoint *HP_skill_get_ammo_qty_post;
+struct HPMHookPoint *HP_skill_get_unit_id_pre;
+struct HPMHookPoint *HP_skill_get_unit_id_post;
+struct HPMHookPoint *HP_skill_get_inf2_pre;
+struct HPMHookPoint *HP_skill_get_inf2_post;
+struct HPMHookPoint *HP_skill_get_castcancel_pre;
+struct HPMHookPoint *HP_skill_get_castcancel_post;
+struct HPMHookPoint *HP_skill_get_maxcount_pre;
+struct HPMHookPoint *HP_skill_get_maxcount_post;
+struct HPMHookPoint *HP_skill_get_blewcount_pre;
+struct HPMHookPoint *HP_skill_get_blewcount_post;
+struct HPMHookPoint *HP_skill_get_unit_flag_pre;
+struct HPMHookPoint *HP_skill_get_unit_flag_post;
+struct HPMHookPoint *HP_skill_get_unit_target_pre;
+struct HPMHookPoint *HP_skill_get_unit_target_post;
+struct HPMHookPoint *HP_skill_get_unit_interval_pre;
+struct HPMHookPoint *HP_skill_get_unit_interval_post;
+struct HPMHookPoint *HP_skill_get_unit_bl_target_pre;
+struct HPMHookPoint *HP_skill_get_unit_bl_target_post;
+struct HPMHookPoint *HP_skill_get_unit_layout_type_pre;
+struct HPMHookPoint *HP_skill_get_unit_layout_type_post;
+struct HPMHookPoint *HP_skill_get_unit_range_pre;
+struct HPMHookPoint *HP_skill_get_unit_range_post;
+struct HPMHookPoint *HP_skill_get_cooldown_pre;
+struct HPMHookPoint *HP_skill_get_cooldown_post;
+struct HPMHookPoint *HP_skill_tree_get_max_pre;
+struct HPMHookPoint *HP_skill_tree_get_max_post;
+struct HPMHookPoint *HP_skill_get_name_pre;
+struct HPMHookPoint *HP_skill_get_name_post;
+struct HPMHookPoint *HP_skill_get_desc_pre;
+struct HPMHookPoint *HP_skill_get_desc_post;
+struct HPMHookPoint *HP_skill_chk_pre;
+struct HPMHookPoint *HP_skill_chk_post;
+struct HPMHookPoint *HP_skill_get_casttype_pre;
+struct HPMHookPoint *HP_skill_get_casttype_post;
+struct HPMHookPoint *HP_skill_get_casttype2_pre;
+struct HPMHookPoint *HP_skill_get_casttype2_post;
+struct HPMHookPoint *HP_skill_name2id_pre;
+struct HPMHookPoint *HP_skill_name2id_post;
+struct HPMHookPoint *HP_skill_isammotype_pre;
+struct HPMHookPoint *HP_skill_isammotype_post;
+struct HPMHookPoint *HP_skill_castend_id_pre;
+struct HPMHookPoint *HP_skill_castend_id_post;
+struct HPMHookPoint *HP_skill_castend_pos_pre;
+struct HPMHookPoint *HP_skill_castend_pos_post;
+struct HPMHookPoint *HP_skill_castend_map_pre;
+struct HPMHookPoint *HP_skill_castend_map_post;
+struct HPMHookPoint *HP_skill_cleartimerskill_pre;
+struct HPMHookPoint *HP_skill_cleartimerskill_post;
+struct HPMHookPoint *HP_skill_addtimerskill_pre;
+struct HPMHookPoint *HP_skill_addtimerskill_post;
+struct HPMHookPoint *HP_skill_additional_effect_pre;
+struct HPMHookPoint *HP_skill_additional_effect_post;
+struct HPMHookPoint *HP_skill_counter_additional_effect_pre;
+struct HPMHookPoint *HP_skill_counter_additional_effect_post;
+struct HPMHookPoint *HP_skill_blown_pre;
+struct HPMHookPoint *HP_skill_blown_post;
+struct HPMHookPoint *HP_skill_break_equip_pre;
+struct HPMHookPoint *HP_skill_break_equip_post;
+struct HPMHookPoint *HP_skill_strip_equip_pre;
+struct HPMHookPoint *HP_skill_strip_equip_post;
+struct HPMHookPoint *HP_skill_id2group_pre;
+struct HPMHookPoint *HP_skill_id2group_post;
+struct HPMHookPoint *HP_skill_unitsetting_pre;
+struct HPMHookPoint *HP_skill_unitsetting_post;
+struct HPMHookPoint *HP_skill_initunit_pre;
+struct HPMHookPoint *HP_skill_initunit_post;
+struct HPMHookPoint *HP_skill_delunit_pre;
+struct HPMHookPoint *HP_skill_delunit_post;
+struct HPMHookPoint *HP_skill_init_unitgroup_pre;
+struct HPMHookPoint *HP_skill_init_unitgroup_post;
+struct HPMHookPoint *HP_skill_del_unitgroup_pre;
+struct HPMHookPoint *HP_skill_del_unitgroup_post;
+struct HPMHookPoint *HP_skill_clear_unitgroup_pre;
+struct HPMHookPoint *HP_skill_clear_unitgroup_post;
+struct HPMHookPoint *HP_skill_clear_group_pre;
+struct HPMHookPoint *HP_skill_clear_group_post;
+struct HPMHookPoint *HP_skill_unit_onplace_pre;
+struct HPMHookPoint *HP_skill_unit_onplace_post;
+struct HPMHookPoint *HP_skill_unit_ondamaged_pre;
+struct HPMHookPoint *HP_skill_unit_ondamaged_post;
+struct HPMHookPoint *HP_skill_cast_fix_pre;
+struct HPMHookPoint *HP_skill_cast_fix_post;
+struct HPMHookPoint *HP_skill_cast_fix_sc_pre;
+struct HPMHookPoint *HP_skill_cast_fix_sc_post;
+struct HPMHookPoint *HP_skill_vf_cast_fix_pre;
+struct HPMHookPoint *HP_skill_vf_cast_fix_post;
+struct HPMHookPoint *HP_skill_delay_fix_pre;
+struct HPMHookPoint *HP_skill_delay_fix_post;
+struct HPMHookPoint *HP_skill_check_condition_castbegin_pre;
+struct HPMHookPoint *HP_skill_check_condition_castbegin_post;
+struct HPMHookPoint *HP_skill_check_condition_castend_pre;
+struct HPMHookPoint *HP_skill_check_condition_castend_post;
+struct HPMHookPoint *HP_skill_consume_requirement_pre;
+struct HPMHookPoint *HP_skill_consume_requirement_post;
+struct HPMHookPoint *HP_skill_get_requirement_pre;
+struct HPMHookPoint *HP_skill_get_requirement_post;
+struct HPMHookPoint *HP_skill_check_pc_partner_pre;
+struct HPMHookPoint *HP_skill_check_pc_partner_post;
+struct HPMHookPoint *HP_skill_unit_move_pre;
+struct HPMHookPoint *HP_skill_unit_move_post;
+struct HPMHookPoint *HP_skill_unit_onleft_pre;
+struct HPMHookPoint *HP_skill_unit_onleft_post;
+struct HPMHookPoint *HP_skill_unit_onout_pre;
+struct HPMHookPoint *HP_skill_unit_onout_post;
+struct HPMHookPoint *HP_skill_unit_move_unit_group_pre;
+struct HPMHookPoint *HP_skill_unit_move_unit_group_post;
+struct HPMHookPoint *HP_skill_sit_pre;
+struct HPMHookPoint *HP_skill_sit_post;
+struct HPMHookPoint *HP_skill_brandishspear_pre;
+struct HPMHookPoint *HP_skill_brandishspear_post;
+struct HPMHookPoint *HP_skill_repairweapon_pre;
+struct HPMHookPoint *HP_skill_repairweapon_post;
+struct HPMHookPoint *HP_skill_identify_pre;
+struct HPMHookPoint *HP_skill_identify_post;
+struct HPMHookPoint *HP_skill_weaponrefine_pre;
+struct HPMHookPoint *HP_skill_weaponrefine_post;
+struct HPMHookPoint *HP_skill_autospell_pre;
+struct HPMHookPoint *HP_skill_autospell_post;
+struct HPMHookPoint *HP_skill_calc_heal_pre;
+struct HPMHookPoint *HP_skill_calc_heal_post;
+struct HPMHookPoint *HP_skill_check_cloaking_pre;
+struct HPMHookPoint *HP_skill_check_cloaking_post;
+struct HPMHookPoint *HP_skill_enchant_elemental_end_pre;
+struct HPMHookPoint *HP_skill_enchant_elemental_end_post;
+struct HPMHookPoint *HP_skill_not_ok_pre;
+struct HPMHookPoint *HP_skill_not_ok_post;
+struct HPMHookPoint *HP_skill_not_ok_hom_pre;
+struct HPMHookPoint *HP_skill_not_ok_hom_post;
+struct HPMHookPoint *HP_skill_not_ok_mercenary_pre;
+struct HPMHookPoint *HP_skill_not_ok_mercenary_post;
+struct HPMHookPoint *HP_skill_chastle_mob_changetarget_pre;
+struct HPMHookPoint *HP_skill_chastle_mob_changetarget_post;
+struct HPMHookPoint *HP_skill_can_produce_mix_pre;
+struct HPMHookPoint *HP_skill_can_produce_mix_post;
+struct HPMHookPoint *HP_skill_produce_mix_pre;
+struct HPMHookPoint *HP_skill_produce_mix_post;
+struct HPMHookPoint *HP_skill_arrow_create_pre;
+struct HPMHookPoint *HP_skill_arrow_create_post;
+struct HPMHookPoint *HP_skill_castend_nodamage_id_pre;
+struct HPMHookPoint *HP_skill_castend_nodamage_id_post;
+struct HPMHookPoint *HP_skill_castend_damage_id_pre;
+struct HPMHookPoint *HP_skill_castend_damage_id_post;
+struct HPMHookPoint *HP_skill_castend_pos2_pre;
+struct HPMHookPoint *HP_skill_castend_pos2_post;
+struct HPMHookPoint *HP_skill_blockpc_start_pre;
+struct HPMHookPoint *HP_skill_blockpc_start_post;
+struct HPMHookPoint *HP_skill_blockhomun_start_pre;
+struct HPMHookPoint *HP_skill_blockhomun_start_post;
+struct HPMHookPoint *HP_skill_blockmerc_start_pre;
+struct HPMHookPoint *HP_skill_blockmerc_start_post;
+struct HPMHookPoint *HP_skill_attack_pre;
+struct HPMHookPoint *HP_skill_attack_post;
+struct HPMHookPoint *HP_skill_attack_area_pre;
+struct HPMHookPoint *HP_skill_attack_area_post;
+struct HPMHookPoint *HP_skill_area_sub_pre;
+struct HPMHookPoint *HP_skill_area_sub_post;
+struct HPMHookPoint *HP_skill_area_sub_count_pre;
+struct HPMHookPoint *HP_skill_area_sub_count_post;
+struct HPMHookPoint *HP_skill_check_unit_range_pre;
+struct HPMHookPoint *HP_skill_check_unit_range_post;
+struct HPMHookPoint *HP_skill_check_unit_range_sub_pre;
+struct HPMHookPoint *HP_skill_check_unit_range_sub_post;
+struct HPMHookPoint *HP_skill_check_unit_range2_pre;
+struct HPMHookPoint *HP_skill_check_unit_range2_post;
+struct HPMHookPoint *HP_skill_check_unit_range2_sub_pre;
+struct HPMHookPoint *HP_skill_check_unit_range2_sub_post;
+struct HPMHookPoint *HP_skill_toggle_magicpower_pre;
+struct HPMHookPoint *HP_skill_toggle_magicpower_post;
+struct HPMHookPoint *HP_skill_magic_reflect_pre;
+struct HPMHookPoint *HP_skill_magic_reflect_post;
+struct HPMHookPoint *HP_skill_onskillusage_pre;
+struct HPMHookPoint *HP_skill_onskillusage_post;
+struct HPMHookPoint *HP_skill_cell_overlap_pre;
+struct HPMHookPoint *HP_skill_cell_overlap_post;
+struct HPMHookPoint *HP_skill_timerskill_pre;
+struct HPMHookPoint *HP_skill_timerskill_post;
+struct HPMHookPoint *HP_skill_trap_splash_pre;
+struct HPMHookPoint *HP_skill_trap_splash_post;
+struct HPMHookPoint *HP_skill_check_condition_mercenary_pre;
+struct HPMHookPoint *HP_skill_check_condition_mercenary_post;
+struct HPMHookPoint *HP_skill_locate_element_field_pre;
+struct HPMHookPoint *HP_skill_locate_element_field_post;
+struct HPMHookPoint *HP_skill_graffitiremover_pre;
+struct HPMHookPoint *HP_skill_graffitiremover_post;
+struct HPMHookPoint *HP_skill_activate_reverberation_pre;
+struct HPMHookPoint *HP_skill_activate_reverberation_post;
+struct HPMHookPoint *HP_skill_dance_overlap_sub_pre;
+struct HPMHookPoint *HP_skill_dance_overlap_sub_post;
+struct HPMHookPoint *HP_skill_dance_overlap_pre;
+struct HPMHookPoint *HP_skill_dance_overlap_post;
+struct HPMHookPoint *HP_skill_get_unit_layout_pre;
+struct HPMHookPoint *HP_skill_get_unit_layout_post;
+struct HPMHookPoint *HP_skill_frostjoke_scream_pre;
+struct HPMHookPoint *HP_skill_frostjoke_scream_post;
+struct HPMHookPoint *HP_skill_greed_pre;
+struct HPMHookPoint *HP_skill_greed_post;
+struct HPMHookPoint *HP_skill_destroy_trap_pre;
+struct HPMHookPoint *HP_skill_destroy_trap_post;
+struct HPMHookPoint *HP_skill_icewall_block_pre;
+struct HPMHookPoint *HP_skill_icewall_block_post;
+struct HPMHookPoint *HP_skill_unitgrouptickset_search_pre;
+struct HPMHookPoint *HP_skill_unitgrouptickset_search_post;
+struct HPMHookPoint *HP_skill_dance_switch_pre;
+struct HPMHookPoint *HP_skill_dance_switch_post;
+struct HPMHookPoint *HP_skill_check_condition_char_sub_pre;
+struct HPMHookPoint *HP_skill_check_condition_char_sub_post;
+struct HPMHookPoint *HP_skill_check_condition_mob_master_sub_pre;
+struct HPMHookPoint *HP_skill_check_condition_mob_master_sub_post;
+struct HPMHookPoint *HP_skill_brandishspear_first_pre;
+struct HPMHookPoint *HP_skill_brandishspear_first_post;
+struct HPMHookPoint *HP_skill_brandishspear_dir_pre;
+struct HPMHookPoint *HP_skill_brandishspear_dir_post;
+struct HPMHookPoint *HP_skill_get_fixed_cast_pre;
+struct HPMHookPoint *HP_skill_get_fixed_cast_post;
+struct HPMHookPoint *HP_skill_sit_count_pre;
+struct HPMHookPoint *HP_skill_sit_count_post;
+struct HPMHookPoint *HP_skill_sit_in_pre;
+struct HPMHookPoint *HP_skill_sit_in_post;
+struct HPMHookPoint *HP_skill_sit_out_pre;
+struct HPMHookPoint *HP_skill_sit_out_post;
+struct HPMHookPoint *HP_skill_unitsetmapcell_pre;
+struct HPMHookPoint *HP_skill_unitsetmapcell_post;
+struct HPMHookPoint *HP_skill_unit_onplace_timer_pre;
+struct HPMHookPoint *HP_skill_unit_onplace_timer_post;
+struct HPMHookPoint *HP_skill_unit_effect_pre;
+struct HPMHookPoint *HP_skill_unit_effect_post;
+struct HPMHookPoint *HP_skill_unit_timer_sub_onplace_pre;
+struct HPMHookPoint *HP_skill_unit_timer_sub_onplace_post;
+struct HPMHookPoint *HP_skill_unit_move_sub_pre;
+struct HPMHookPoint *HP_skill_unit_move_sub_post;
+struct HPMHookPoint *HP_skill_blockpc_end_pre;
+struct HPMHookPoint *HP_skill_blockpc_end_post;
+struct HPMHookPoint *HP_skill_blockhomun_end_pre;
+struct HPMHookPoint *HP_skill_blockhomun_end_post;
+struct HPMHookPoint *HP_skill_blockmerc_end_pre;
+struct HPMHookPoint *HP_skill_blockmerc_end_post;
+struct HPMHookPoint *HP_skill_split_atoi_pre;
+struct HPMHookPoint *HP_skill_split_atoi_post;
+struct HPMHookPoint *HP_skill_unit_timer_pre;
+struct HPMHookPoint *HP_skill_unit_timer_post;
+struct HPMHookPoint *HP_skill_unit_timer_sub_pre;
+struct HPMHookPoint *HP_skill_unit_timer_sub_post;
+struct HPMHookPoint *HP_skill_init_unit_layout_pre;
+struct HPMHookPoint *HP_skill_init_unit_layout_post;
+struct HPMHookPoint *HP_skill_parse_row_skilldb_pre;
+struct HPMHookPoint *HP_skill_parse_row_skilldb_post;
+struct HPMHookPoint *HP_skill_parse_row_requiredb_pre;
+struct HPMHookPoint *HP_skill_parse_row_requiredb_post;
+struct HPMHookPoint *HP_skill_parse_row_castdb_pre;
+struct HPMHookPoint *HP_skill_parse_row_castdb_post;
+struct HPMHookPoint *HP_skill_parse_row_castnodexdb_pre;
+struct HPMHookPoint *HP_skill_parse_row_castnodexdb_post;
+struct HPMHookPoint *HP_skill_parse_row_unitdb_pre;
+struct HPMHookPoint *HP_skill_parse_row_unitdb_post;
+struct HPMHookPoint *HP_skill_parse_row_producedb_pre;
+struct HPMHookPoint *HP_skill_parse_row_producedb_post;
+struct HPMHookPoint *HP_skill_parse_row_createarrowdb_pre;
+struct HPMHookPoint *HP_skill_parse_row_createarrowdb_post;
+struct HPMHookPoint *HP_skill_parse_row_abradb_pre;
+struct HPMHookPoint *HP_skill_parse_row_abradb_post;
+struct HPMHookPoint *HP_skill_parse_row_spellbookdb_pre;
+struct HPMHookPoint *HP_skill_parse_row_spellbookdb_post;
+struct HPMHookPoint *HP_skill_parse_row_magicmushroomdb_pre;
+struct HPMHookPoint *HP_skill_parse_row_magicmushroomdb_post;
+struct HPMHookPoint *HP_skill_parse_row_reproducedb_pre;
+struct HPMHookPoint *HP_skill_parse_row_reproducedb_post;
+struct HPMHookPoint *HP_skill_parse_row_improvisedb_pre;
+struct HPMHookPoint *HP_skill_parse_row_improvisedb_post;
+struct HPMHookPoint *HP_skill_parse_row_changematerialdb_pre;
+struct HPMHookPoint *HP_skill_parse_row_changematerialdb_post;
+struct HPMHookPoint *HP_skill_usave_add_pre;
+struct HPMHookPoint *HP_skill_usave_add_post;
+struct HPMHookPoint *HP_skill_usave_trigger_pre;
+struct HPMHookPoint *HP_skill_usave_trigger_post;
+struct HPMHookPoint *HP_skill_cooldown_load_pre;
+struct HPMHookPoint *HP_skill_cooldown_load_post;
+struct HPMHookPoint *HP_skill_spellbook_pre;
+struct HPMHookPoint *HP_skill_spellbook_post;
+struct HPMHookPoint *HP_skill_block_check_pre;
+struct HPMHookPoint *HP_skill_block_check_post;
+struct HPMHookPoint *HP_skill_detonator_pre;
+struct HPMHookPoint *HP_skill_detonator_post;
+struct HPMHookPoint *HP_skill_check_camouflage_pre;
+struct HPMHookPoint *HP_skill_check_camouflage_post;
+struct HPMHookPoint *HP_skill_magicdecoy_pre;
+struct HPMHookPoint *HP_skill_magicdecoy_post;
+struct HPMHookPoint *HP_skill_poisoningweapon_pre;
+struct HPMHookPoint *HP_skill_poisoningweapon_post;
+struct HPMHookPoint *HP_skill_select_menu_pre;
+struct HPMHookPoint *HP_skill_select_menu_post;
+struct HPMHookPoint *HP_skill_elementalanalysis_pre;
+struct HPMHookPoint *HP_skill_elementalanalysis_post;
+struct HPMHookPoint *HP_skill_changematerial_pre;
+struct HPMHookPoint *HP_skill_changematerial_post;
+struct HPMHookPoint *HP_skill_get_elemental_type_pre;
+struct HPMHookPoint *HP_skill_get_elemental_type_post;
+struct HPMHookPoint *HP_skill_cooldown_save_pre;
+struct HPMHookPoint *HP_skill_cooldown_save_post;
+struct HPMHookPoint *HP_skill_maelstrom_suction_pre;
+struct HPMHookPoint *HP_skill_maelstrom_suction_post;
+struct HPMHookPoint *HP_skill_get_new_group_id_pre;
+struct HPMHookPoint *HP_skill_get_new_group_id_post;
+struct HPMHookPoint *HP_status_init_pre;
+struct HPMHookPoint *HP_status_init_post;
+struct HPMHookPoint *HP_status_final_pre;
+struct HPMHookPoint *HP_status_final_post;
+struct HPMHookPoint *HP_status_get_refine_chance_pre;
+struct HPMHookPoint *HP_status_get_refine_chance_post;
+struct HPMHookPoint *HP_status_skill2sc_pre;
+struct HPMHookPoint *HP_status_skill2sc_post;
+struct HPMHookPoint *HP_status_sc2skill_pre;
+struct HPMHookPoint *HP_status_sc2skill_post;
+struct HPMHookPoint *HP_status_sc2scb_flag_pre;
+struct HPMHookPoint *HP_status_sc2scb_flag_post;
+struct HPMHookPoint *HP_status_type2relevant_bl_types_pre;
+struct HPMHookPoint *HP_status_type2relevant_bl_types_post;
+struct HPMHookPoint *HP_status_get_sc_type_pre;
+struct HPMHookPoint *HP_status_get_sc_type_post;
+struct HPMHookPoint *HP_status_damage_pre;
+struct HPMHookPoint *HP_status_damage_post;
+struct HPMHookPoint *HP_status_charge_pre;
+struct HPMHookPoint *HP_status_charge_post;
+struct HPMHookPoint *HP_status_percent_change_pre;
+struct HPMHookPoint *HP_status_percent_change_post;
+struct HPMHookPoint *HP_status_set_hp_pre;
+struct HPMHookPoint *HP_status_set_hp_post;
+struct HPMHookPoint *HP_status_set_sp_pre;
+struct HPMHookPoint *HP_status_set_sp_post;
+struct HPMHookPoint *HP_status_heal_pre;
+struct HPMHookPoint *HP_status_heal_post;
+struct HPMHookPoint *HP_status_revive_pre;
+struct HPMHookPoint *HP_status_revive_post;
+struct HPMHookPoint *HP_status_get_regen_data_pre;
+struct HPMHookPoint *HP_status_get_regen_data_post;
+struct HPMHookPoint *HP_status_get_status_data_pre;
+struct HPMHookPoint *HP_status_get_status_data_post;
+struct HPMHookPoint *HP_status_get_base_status_pre;
+struct HPMHookPoint *HP_status_get_base_status_post;
+struct HPMHookPoint *HP_status_get_name_pre;
+struct HPMHookPoint *HP_status_get_name_post;
+struct HPMHookPoint *HP_status_get_class_pre;
+struct HPMHookPoint *HP_status_get_class_post;
+struct HPMHookPoint *HP_status_get_lv_pre;
+struct HPMHookPoint *HP_status_get_lv_post;
+struct HPMHookPoint *HP_status_get_def_pre;
+struct HPMHookPoint *HP_status_get_def_post;
+struct HPMHookPoint *HP_status_get_speed_pre;
+struct HPMHookPoint *HP_status_get_speed_post;
+struct HPMHookPoint *HP_status_calc_attack_element_pre;
+struct HPMHookPoint *HP_status_calc_attack_element_post;
+struct HPMHookPoint *HP_status_get_party_id_pre;
+struct HPMHookPoint *HP_status_get_party_id_post;
+struct HPMHookPoint *HP_status_get_guild_id_pre;
+struct HPMHookPoint *HP_status_get_guild_id_post;
+struct HPMHookPoint *HP_status_get_emblem_id_pre;
+struct HPMHookPoint *HP_status_get_emblem_id_post;
+struct HPMHookPoint *HP_status_get_mexp_pre;
+struct HPMHookPoint *HP_status_get_mexp_post;
+struct HPMHookPoint *HP_status_get_race2_pre;
+struct HPMHookPoint *HP_status_get_race2_post;
+struct HPMHookPoint *HP_status_get_viewdata_pre;
+struct HPMHookPoint *HP_status_get_viewdata_post;
+struct HPMHookPoint *HP_status_set_viewdata_pre;
+struct HPMHookPoint *HP_status_set_viewdata_post;
+struct HPMHookPoint *HP_status_change_init_pre;
+struct HPMHookPoint *HP_status_change_init_post;
+struct HPMHookPoint *HP_status_get_sc_pre;
+struct HPMHookPoint *HP_status_get_sc_post;
+struct HPMHookPoint *HP_status_isdead_pre;
+struct HPMHookPoint *HP_status_isdead_post;
+struct HPMHookPoint *HP_status_isimmune_pre;
+struct HPMHookPoint *HP_status_isimmune_post;
+struct HPMHookPoint *HP_status_get_sc_def_pre;
+struct HPMHookPoint *HP_status_get_sc_def_post;
+struct HPMHookPoint *HP_status_change_start_pre;
+struct HPMHookPoint *HP_status_change_start_post;
+struct HPMHookPoint *HP_status_change_end__pre;
+struct HPMHookPoint *HP_status_change_end__post;
+struct HPMHookPoint *HP_status_kaahi_heal_timer_pre;
+struct HPMHookPoint *HP_status_kaahi_heal_timer_post;
+struct HPMHookPoint *HP_status_change_timer_pre;
+struct HPMHookPoint *HP_status_change_timer_post;
+struct HPMHookPoint *HP_status_change_timer_sub_pre;
+struct HPMHookPoint *HP_status_change_timer_sub_post;
+struct HPMHookPoint *HP_status_change_clear_pre;
+struct HPMHookPoint *HP_status_change_clear_post;
+struct HPMHookPoint *HP_status_change_clear_buffs_pre;
+struct HPMHookPoint *HP_status_change_clear_buffs_post;
+struct HPMHookPoint *HP_status_calc_bl__pre;
+struct HPMHookPoint *HP_status_calc_bl__post;
+struct HPMHookPoint *HP_status_calc_mob__pre;
+struct HPMHookPoint *HP_status_calc_mob__post;
+struct HPMHookPoint *HP_status_calc_pet__pre;
+struct HPMHookPoint *HP_status_calc_pet__post;
+struct HPMHookPoint *HP_status_calc_pc__pre;
+struct HPMHookPoint *HP_status_calc_pc__post;
+struct HPMHookPoint *HP_status_calc_homunculus__pre;
+struct HPMHookPoint *HP_status_calc_homunculus__post;
+struct HPMHookPoint *HP_status_calc_mercenary__pre;
+struct HPMHookPoint *HP_status_calc_mercenary__post;
+struct HPMHookPoint *HP_status_calc_elemental__pre;
+struct HPMHookPoint *HP_status_calc_elemental__post;
+struct HPMHookPoint *HP_status_calc_misc_pre;
+struct HPMHookPoint *HP_status_calc_misc_post;
+struct HPMHookPoint *HP_status_calc_regen_pre;
+struct HPMHookPoint *HP_status_calc_regen_post;
+struct HPMHookPoint *HP_status_calc_regen_rate_pre;
+struct HPMHookPoint *HP_status_calc_regen_rate_post;
+struct HPMHookPoint *HP_status_check_skilluse_pre;
+struct HPMHookPoint *HP_status_check_skilluse_post;
+struct HPMHookPoint *HP_status_check_visibility_pre;
+struct HPMHookPoint *HP_status_check_visibility_post;
+struct HPMHookPoint *HP_status_change_spread_pre;
+struct HPMHookPoint *HP_status_change_spread_post;
+struct HPMHookPoint *HP_status_calc_def_pre;
+struct HPMHookPoint *HP_status_calc_def_post;
+struct HPMHookPoint *HP_status_calc_def2_pre;
+struct HPMHookPoint *HP_status_calc_def2_post;
+struct HPMHookPoint *HP_status_calc_mdef_pre;
+struct HPMHookPoint *HP_status_calc_mdef_post;
+struct HPMHookPoint *HP_status_calc_mdef2_pre;
+struct HPMHookPoint *HP_status_calc_mdef2_post;
+struct HPMHookPoint *HP_status_calc_batk_pre;
+struct HPMHookPoint *HP_status_calc_batk_post;
+struct HPMHookPoint *HP_status_get_total_mdef_pre;
+struct HPMHookPoint *HP_status_get_total_mdef_post;
+struct HPMHookPoint *HP_status_get_total_def_pre;
+struct HPMHookPoint *HP_status_get_total_def_post;
+struct HPMHookPoint *HP_status_get_matk_pre;
+struct HPMHookPoint *HP_status_get_matk_post;
+struct HPMHookPoint *HP_status_readdb_pre;
+struct HPMHookPoint *HP_status_readdb_post;
+struct HPMHookPoint *HP_status_initChangeTables_pre;
+struct HPMHookPoint *HP_status_initChangeTables_post;
+struct HPMHookPoint *HP_status_initDummyData_pre;
+struct HPMHookPoint *HP_status_initDummyData_post;
+struct HPMHookPoint *HP_status_base_amotion_pc_pre;
+struct HPMHookPoint *HP_status_base_amotion_pc_post;
+struct HPMHookPoint *HP_status_base_atk_pre;
+struct HPMHookPoint *HP_status_base_atk_post;
+struct HPMHookPoint *HP_status_calc_sigma_pre;
+struct HPMHookPoint *HP_status_calc_sigma_post;
+struct HPMHookPoint *HP_status_base_pc_maxhp_pre;
+struct HPMHookPoint *HP_status_base_pc_maxhp_post;
+struct HPMHookPoint *HP_status_base_pc_maxsp_pre;
+struct HPMHookPoint *HP_status_base_pc_maxsp_post;
+struct HPMHookPoint *HP_status_calc_npc__pre;
+struct HPMHookPoint *HP_status_calc_npc__post;
+struct HPMHookPoint *HP_status_calc_str_pre;
+struct HPMHookPoint *HP_status_calc_str_post;
+struct HPMHookPoint *HP_status_calc_agi_pre;
+struct HPMHookPoint *HP_status_calc_agi_post;
+struct HPMHookPoint *HP_status_calc_vit_pre;
+struct HPMHookPoint *HP_status_calc_vit_post;
+struct HPMHookPoint *HP_status_calc_int_pre;
+struct HPMHookPoint *HP_status_calc_int_post;
+struct HPMHookPoint *HP_status_calc_dex_pre;
+struct HPMHookPoint *HP_status_calc_dex_post;
+struct HPMHookPoint *HP_status_calc_luk_pre;
+struct HPMHookPoint *HP_status_calc_luk_post;
+struct HPMHookPoint *HP_status_calc_watk_pre;
+struct HPMHookPoint *HP_status_calc_watk_post;
+struct HPMHookPoint *HP_status_calc_matk_pre;
+struct HPMHookPoint *HP_status_calc_matk_post;
+struct HPMHookPoint *HP_status_calc_hit_pre;
+struct HPMHookPoint *HP_status_calc_hit_post;
+struct HPMHookPoint *HP_status_calc_critical_pre;
+struct HPMHookPoint *HP_status_calc_critical_post;
+struct HPMHookPoint *HP_status_calc_flee_pre;
+struct HPMHookPoint *HP_status_calc_flee_post;
+struct HPMHookPoint *HP_status_calc_flee2_pre;
+struct HPMHookPoint *HP_status_calc_flee2_post;
+struct HPMHookPoint *HP_status_calc_speed_pre;
+struct HPMHookPoint *HP_status_calc_speed_post;
+struct HPMHookPoint *HP_status_calc_aspd_rate_pre;
+struct HPMHookPoint *HP_status_calc_aspd_rate_post;
+struct HPMHookPoint *HP_status_calc_dmotion_pre;
+struct HPMHookPoint *HP_status_calc_dmotion_post;
+struct HPMHookPoint *HP_status_calc_fix_aspd_pre;
+struct HPMHookPoint *HP_status_calc_fix_aspd_post;
+struct HPMHookPoint *HP_status_calc_maxhp_pre;
+struct HPMHookPoint *HP_status_calc_maxhp_post;
+struct HPMHookPoint *HP_status_calc_maxsp_pre;
+struct HPMHookPoint *HP_status_calc_maxsp_post;
+struct HPMHookPoint *HP_status_calc_element_pre;
+struct HPMHookPoint *HP_status_calc_element_post;
+struct HPMHookPoint *HP_status_calc_element_lv_pre;
+struct HPMHookPoint *HP_status_calc_element_lv_post;
+struct HPMHookPoint *HP_status_calc_mode_pre;
+struct HPMHookPoint *HP_status_calc_mode_post;
+struct HPMHookPoint *HP_status_calc_bl_main_pre;
+struct HPMHookPoint *HP_status_calc_bl_main_post;
+struct HPMHookPoint *HP_status_display_add_pre;
+struct HPMHookPoint *HP_status_display_add_post;
+struct HPMHookPoint *HP_status_display_remove_pre;
+struct HPMHookPoint *HP_status_display_remove_post;
+struct HPMHookPoint *HP_status_natural_heal_pre;
+struct HPMHookPoint *HP_status_natural_heal_post;
+struct HPMHookPoint *HP_status_natural_heal_timer_pre;
+struct HPMHookPoint *HP_status_natural_heal_timer_post;
+struct HPMHookPoint *HP_status_readdb_job1_pre;
+struct HPMHookPoint *HP_status_readdb_job1_post;
+struct HPMHookPoint *HP_status_readdb_job2_pre;
+struct HPMHookPoint *HP_status_readdb_job2_post;
+struct HPMHookPoint *HP_status_readdb_sizefix_pre;
+struct HPMHookPoint *HP_status_readdb_sizefix_post;
+struct HPMHookPoint *HP_status_readdb_refine_pre;
+struct HPMHookPoint *HP_status_readdb_refine_post;
+struct HPMHookPoint *HP_status_readdb_scconfig_pre;
+struct HPMHookPoint *HP_status_readdb_scconfig_post;
+struct HPMHookPoint *HP_storage_reconnect_pre;
+struct HPMHookPoint *HP_storage_reconnect_post;
+struct HPMHookPoint *HP_storage_delitem_pre;
+struct HPMHookPoint *HP_storage_delitem_post;
+struct HPMHookPoint *HP_storage_open_pre;
+struct HPMHookPoint *HP_storage_open_post;
+struct HPMHookPoint *HP_storage_add_pre;
+struct HPMHookPoint *HP_storage_add_post;
+struct HPMHookPoint *HP_storage_get_pre;
+struct HPMHookPoint *HP_storage_get_post;
+struct HPMHookPoint *HP_storage_additem_pre;
+struct HPMHookPoint *HP_storage_additem_post;
+struct HPMHookPoint *HP_storage_addfromcart_pre;
+struct HPMHookPoint *HP_storage_addfromcart_post;
+struct HPMHookPoint *HP_storage_gettocart_pre;
+struct HPMHookPoint *HP_storage_gettocart_post;
+struct HPMHookPoint *HP_storage_close_pre;
+struct HPMHookPoint *HP_storage_close_post;
+struct HPMHookPoint *HP_storage_pc_quit_pre;
+struct HPMHookPoint *HP_storage_pc_quit_post;
+struct HPMHookPoint *HP_storage_comp_item_pre;
+struct HPMHookPoint *HP_storage_comp_item_post;
+struct HPMHookPoint *HP_storage_sortitem_pre;
+struct HPMHookPoint *HP_storage_sortitem_post;
+struct HPMHookPoint *HP_storage_reconnect_sub_pre;
+struct HPMHookPoint *HP_storage_reconnect_sub_post;
+struct HPMHookPoint *HP_trade_request_pre;
+struct HPMHookPoint *HP_trade_request_post;
+struct HPMHookPoint *HP_trade_ack_pre;
+struct HPMHookPoint *HP_trade_ack_post;
+struct HPMHookPoint *HP_trade_check_impossible_pre;
+struct HPMHookPoint *HP_trade_check_impossible_post;
+struct HPMHookPoint *HP_trade_check_pre;
+struct HPMHookPoint *HP_trade_check_post;
+struct HPMHookPoint *HP_trade_additem_pre;
+struct HPMHookPoint *HP_trade_additem_post;
+struct HPMHookPoint *HP_trade_addzeny_pre;
+struct HPMHookPoint *HP_trade_addzeny_post;
+struct HPMHookPoint *HP_trade_ok_pre;
+struct HPMHookPoint *HP_trade_ok_post;
+struct HPMHookPoint *HP_trade_cancel_pre;
+struct HPMHookPoint *HP_trade_cancel_post;
+struct HPMHookPoint *HP_trade_commit_pre;
+struct HPMHookPoint *HP_trade_commit_post;
+struct HPMHookPoint *HP_unit_init_pre;
+struct HPMHookPoint *HP_unit_init_post;
+struct HPMHookPoint *HP_unit_final_pre;
+struct HPMHookPoint *HP_unit_final_post;
+struct HPMHookPoint *HP_unit_bl2ud_pre;
+struct HPMHookPoint *HP_unit_bl2ud_post;
+struct HPMHookPoint *HP_unit_bl2ud2_pre;
+struct HPMHookPoint *HP_unit_bl2ud2_post;
+struct HPMHookPoint *HP_unit_attack_timer_pre;
+struct HPMHookPoint *HP_unit_attack_timer_post;
+struct HPMHookPoint *HP_unit_walktoxy_timer_pre;
+struct HPMHookPoint *HP_unit_walktoxy_timer_post;
+struct HPMHookPoint *HP_unit_walktoxy_sub_pre;
+struct HPMHookPoint *HP_unit_walktoxy_sub_post;
+struct HPMHookPoint *HP_unit_delay_walktoxy_timer_pre;
+struct HPMHookPoint *HP_unit_delay_walktoxy_timer_post;
+struct HPMHookPoint *HP_unit_walktoxy_pre;
+struct HPMHookPoint *HP_unit_walktoxy_post;
+struct HPMHookPoint *HP_unit_walktobl_sub_pre;
+struct HPMHookPoint *HP_unit_walktobl_sub_post;
+struct HPMHookPoint *HP_unit_walktobl_pre;
+struct HPMHookPoint *HP_unit_walktobl_post;
+struct HPMHookPoint *HP_unit_run_pre;
+struct HPMHookPoint *HP_unit_run_post;
+struct HPMHookPoint *HP_unit_wugdash_pre;
+struct HPMHookPoint *HP_unit_wugdash_post;
+struct HPMHookPoint *HP_unit_escape_pre;
+struct HPMHookPoint *HP_unit_escape_post;
+struct HPMHookPoint *HP_unit_movepos_pre;
+struct HPMHookPoint *HP_unit_movepos_post;
+struct HPMHookPoint *HP_unit_setdir_pre;
+struct HPMHookPoint *HP_unit_setdir_post;
+struct HPMHookPoint *HP_unit_getdir_pre;
+struct HPMHookPoint *HP_unit_getdir_post;
+struct HPMHookPoint *HP_unit_blown_pre;
+struct HPMHookPoint *HP_unit_blown_post;
+struct HPMHookPoint *HP_unit_warp_pre;
+struct HPMHookPoint *HP_unit_warp_post;
+struct HPMHookPoint *HP_unit_stop_walking_pre;
+struct HPMHookPoint *HP_unit_stop_walking_post;
+struct HPMHookPoint *HP_unit_skilluse_id_pre;
+struct HPMHookPoint *HP_unit_skilluse_id_post;
+struct HPMHookPoint *HP_unit_is_walking_pre;
+struct HPMHookPoint *HP_unit_is_walking_post;
+struct HPMHookPoint *HP_unit_can_move_pre;
+struct HPMHookPoint *HP_unit_can_move_post;
+struct HPMHookPoint *HP_unit_resume_running_pre;
+struct HPMHookPoint *HP_unit_resume_running_post;
+struct HPMHookPoint *HP_unit_set_walkdelay_pre;
+struct HPMHookPoint *HP_unit_set_walkdelay_post;
+struct HPMHookPoint *HP_unit_skilluse_id2_pre;
+struct HPMHookPoint *HP_unit_skilluse_id2_post;
+struct HPMHookPoint *HP_unit_skilluse_pos_pre;
+struct HPMHookPoint *HP_unit_skilluse_pos_post;
+struct HPMHookPoint *HP_unit_skilluse_pos2_pre;
+struct HPMHookPoint *HP_unit_skilluse_pos2_post;
+struct HPMHookPoint *HP_unit_set_target_pre;
+struct HPMHookPoint *HP_unit_set_target_post;
+struct HPMHookPoint *HP_unit_stop_attack_pre;
+struct HPMHookPoint *HP_unit_stop_attack_post;
+struct HPMHookPoint *HP_unit_unattackable_pre;
+struct HPMHookPoint *HP_unit_unattackable_post;
+struct HPMHookPoint *HP_unit_attack_pre;
+struct HPMHookPoint *HP_unit_attack_post;
+struct HPMHookPoint *HP_unit_cancel_combo_pre;
+struct HPMHookPoint *HP_unit_cancel_combo_post;
+struct HPMHookPoint *HP_unit_can_reach_pos_pre;
+struct HPMHookPoint *HP_unit_can_reach_pos_post;
+struct HPMHookPoint *HP_unit_can_reach_bl_pre;
+struct HPMHookPoint *HP_unit_can_reach_bl_post;
+struct HPMHookPoint *HP_unit_calc_pos_pre;
+struct HPMHookPoint *HP_unit_calc_pos_post;
+struct HPMHookPoint *HP_unit_attack_timer_sub_pre;
+struct HPMHookPoint *HP_unit_attack_timer_sub_post;
+struct HPMHookPoint *HP_unit_skillcastcancel_pre;
+struct HPMHookPoint *HP_unit_skillcastcancel_post;
+struct HPMHookPoint *HP_unit_dataset_pre;
+struct HPMHookPoint *HP_unit_dataset_post;
+struct HPMHookPoint *HP_unit_counttargeted_pre;
+struct HPMHookPoint *HP_unit_counttargeted_post;
+struct HPMHookPoint *HP_unit_fixdamage_pre;
+struct HPMHookPoint *HP_unit_fixdamage_post;
+struct HPMHookPoint *HP_unit_changeviewsize_pre;
+struct HPMHookPoint *HP_unit_changeviewsize_post;
+struct HPMHookPoint *HP_unit_remove_map_pre;
+struct HPMHookPoint *HP_unit_remove_map_post;
+struct HPMHookPoint *HP_unit_remove_map_pc_pre;
+struct HPMHookPoint *HP_unit_remove_map_pc_post;
+struct HPMHookPoint *HP_unit_free_pc_pre;
+struct HPMHookPoint *HP_unit_free_pc_post;
+struct HPMHookPoint *HP_unit_free_pre;
+struct HPMHookPoint *HP_unit_free_post;
+struct HPMHookPoint *HP_vending_init_pre;
+struct HPMHookPoint *HP_vending_init_post;
+struct HPMHookPoint *HP_vending_final_pre;
+struct HPMHookPoint *HP_vending_final_post;
+struct HPMHookPoint *HP_vending_close_pre;
+struct HPMHookPoint *HP_vending_close_post;
+struct HPMHookPoint *HP_vending_open_pre;
+struct HPMHookPoint *HP_vending_open_post;
+struct HPMHookPoint *HP_vending_list_pre;
+struct HPMHookPoint *HP_vending_list_post;
+struct HPMHookPoint *HP_vending_purchase_pre;
+struct HPMHookPoint *HP_vending_purchase_post;
+struct HPMHookPoint *HP_vending_search_pre;
+struct HPMHookPoint *HP_vending_search_post;
+struct HPMHookPoint *HP_vending_searchall_pre;
+struct HPMHookPoint *HP_vending_searchall_post;
+} list;
+struct {
+int HP_atcommand_init_pre;
+int HP_atcommand_init_post;
+int HP_atcommand_final_pre;
+int HP_atcommand_final_post;
+int HP_atcommand_parse_pre;
+int HP_atcommand_parse_post;
+int HP_atcommand_create_pre;
+int HP_atcommand_create_post;
+int HP_atcommand_can_use_pre;
+int HP_atcommand_can_use_post;
+int HP_atcommand_can_use2_pre;
+int HP_atcommand_can_use2_post;
+int HP_atcommand_load_groups_pre;
+int HP_atcommand_load_groups_post;
+int HP_atcommand_exists_pre;
+int HP_atcommand_exists_post;
+int HP_atcommand_msg_read_pre;
+int HP_atcommand_msg_read_post;
+int HP_atcommand_final_msg_pre;
+int HP_atcommand_final_msg_post;
+int HP_atcommand_get_bind_byname_pre;
+int HP_atcommand_get_bind_byname_post;
+int HP_atcommand_get_info_byname_pre;
+int HP_atcommand_get_info_byname_post;
+int HP_atcommand_check_alias_pre;
+int HP_atcommand_check_alias_post;
+int HP_atcommand_get_suggestions_pre;
+int HP_atcommand_get_suggestions_post;
+int HP_atcommand_config_read_pre;
+int HP_atcommand_config_read_post;
+int HP_atcommand_stopattack_pre;
+int HP_atcommand_stopattack_post;
+int HP_atcommand_pvpoff_sub_pre;
+int HP_atcommand_pvpoff_sub_post;
+int HP_atcommand_pvpon_sub_pre;
+int HP_atcommand_pvpon_sub_post;
+int HP_atcommand_atkillmonster_sub_pre;
+int HP_atcommand_atkillmonster_sub_post;
+int HP_atcommand_raise_sub_pre;
+int HP_atcommand_raise_sub_post;
+int HP_atcommand_get_jail_time_pre;
+int HP_atcommand_get_jail_time_post;
+int HP_atcommand_cleanfloor_sub_pre;
+int HP_atcommand_cleanfloor_sub_post;
+int HP_atcommand_mutearea_sub_pre;
+int HP_atcommand_mutearea_sub_post;
+int HP_atcommand_commands_sub_pre;
+int HP_atcommand_commands_sub_post;
+int HP_atcommand_cmd_db_clear_pre;
+int HP_atcommand_cmd_db_clear_post;
+int HP_atcommand_cmd_db_clear_sub_pre;
+int HP_atcommand_cmd_db_clear_sub_post;
+int HP_atcommand_doload_pre;
+int HP_atcommand_doload_post;
+int HP_atcommand_base_commands_pre;
+int HP_atcommand_base_commands_post;
+int HP_battle_init_pre;
+int HP_battle_init_post;
+int HP_battle_final_pre;
+int HP_battle_final_post;
+int HP_battle_calc_attack_pre;
+int HP_battle_calc_attack_post;
+int HP_battle_calc_damage_pre;
+int HP_battle_calc_damage_post;
+int HP_battle_calc_gvg_damage_pre;
+int HP_battle_calc_gvg_damage_post;
+int HP_battle_calc_bg_damage_pre;
+int HP_battle_calc_bg_damage_post;
+int HP_battle_weapon_attack_pre;
+int HP_battle_weapon_attack_post;
+int HP_battle_calc_weapon_attack_pre;
+int HP_battle_calc_weapon_attack_post;
+int HP_battle_delay_damage_pre;
+int HP_battle_delay_damage_post;
+int HP_battle_drain_pre;
+int HP_battle_drain_post;
+int HP_battle_calc_return_damage_pre;
+int HP_battle_calc_return_damage_post;
+int HP_battle_attr_ratio_pre;
+int HP_battle_attr_ratio_post;
+int HP_battle_attr_fix_pre;
+int HP_battle_attr_fix_post;
+int HP_battle_calc_cardfix_pre;
+int HP_battle_calc_cardfix_post;
+int HP_battle_calc_elefix_pre;
+int HP_battle_calc_elefix_post;
+int HP_battle_calc_masteryfix_pre;
+int HP_battle_calc_masteryfix_post;
+int HP_battle_calc_skillratio_pre;
+int HP_battle_calc_skillratio_post;
+int HP_battle_calc_sizefix_pre;
+int HP_battle_calc_sizefix_post;
+int HP_battle_calc_weapon_damage_pre;
+int HP_battle_calc_weapon_damage_post;
+int HP_battle_calc_defense_pre;
+int HP_battle_calc_defense_post;
+int HP_battle_get_master_pre;
+int HP_battle_get_master_post;
+int HP_battle_get_targeted_pre;
+int HP_battle_get_targeted_post;
+int HP_battle_get_enemy_pre;
+int HP_battle_get_enemy_post;
+int HP_battle_get_target_pre;
+int HP_battle_get_target_post;
+int HP_battle_get_current_skill_pre;
+int HP_battle_get_current_skill_post;
+int HP_battle_check_undead_pre;
+int HP_battle_check_undead_post;
+int HP_battle_check_target_pre;
+int HP_battle_check_target_post;
+int HP_battle_check_range_pre;
+int HP_battle_check_range_post;
+int HP_battle_consume_ammo_pre;
+int HP_battle_consume_ammo_post;
+int HP_battle_get_targeted_sub_pre;
+int HP_battle_get_targeted_sub_post;
+int HP_battle_get_enemy_sub_pre;
+int HP_battle_get_enemy_sub_post;
+int HP_battle_get_enemy_area_sub_pre;
+int HP_battle_get_enemy_area_sub_post;
+int HP_battle_delay_damage_sub_pre;
+int HP_battle_delay_damage_sub_post;
+int HP_battle_blewcount_bonus_pre;
+int HP_battle_blewcount_bonus_post;
+int HP_battle_range_type_pre;
+int HP_battle_range_type_post;
+int HP_battle_calc_base_damage_pre;
+int HP_battle_calc_base_damage_post;
+int HP_battle_calc_base_damage2_pre;
+int HP_battle_calc_base_damage2_post;
+int HP_battle_calc_misc_attack_pre;
+int HP_battle_calc_misc_attack_post;
+int HP_battle_calc_magic_attack_pre;
+int HP_battle_calc_magic_attack_post;
+int HP_battle_adjust_skill_damage_pre;
+int HP_battle_adjust_skill_damage_post;
+int HP_battle_add_mastery_pre;
+int HP_battle_add_mastery_post;
+int HP_battle_calc_drain_pre;
+int HP_battle_calc_drain_post;
+int HP_battle_config_read_pre;
+int HP_battle_config_read_post;
+int HP_battle_config_set_defaults_pre;
+int HP_battle_config_set_defaults_post;
+int HP_battle_config_set_value_pre;
+int HP_battle_config_set_value_post;
+int HP_battle_config_get_value_pre;
+int HP_battle_config_get_value_post;
+int HP_battle_config_adjust_pre;
+int HP_battle_config_adjust_post;
+int HP_battle_get_enemy_area_pre;
+int HP_battle_get_enemy_area_post;
+int HP_battle_damage_area_pre;
+int HP_battle_damage_area_post;
+int HP_bg_init_pre;
+int HP_bg_init_post;
+int HP_bg_final_pre;
+int HP_bg_final_post;
+int HP_bg_name2arena_pre;
+int HP_bg_name2arena_post;
+int HP_bg_queue_add_pre;
+int HP_bg_queue_add_post;
+int HP_bg_can_queue_pre;
+int HP_bg_can_queue_post;
+int HP_bg_id2pos_pre;
+int HP_bg_id2pos_post;
+int HP_bg_queue_pc_cleanup_pre;
+int HP_bg_queue_pc_cleanup_post;
+int HP_bg_begin_pre;
+int HP_bg_begin_post;
+int HP_bg_begin_timer_pre;
+int HP_bg_begin_timer_post;
+int HP_bg_queue_pregame_pre;
+int HP_bg_queue_pregame_post;
+int HP_bg_fillup_timer_pre;
+int HP_bg_fillup_timer_post;
+int HP_bg_queue_ready_ack_pre;
+int HP_bg_queue_ready_ack_post;
+int HP_bg_match_over_pre;
+int HP_bg_match_over_post;
+int HP_bg_queue_check_pre;
+int HP_bg_queue_check_post;
+int HP_bg_team_search_pre;
+int HP_bg_team_search_post;
+int HP_bg_getavailablesd_pre;
+int HP_bg_getavailablesd_post;
+int HP_bg_team_delete_pre;
+int HP_bg_team_delete_post;
+int HP_bg_team_warp_pre;
+int HP_bg_team_warp_post;
+int HP_bg_send_dot_remove_pre;
+int HP_bg_send_dot_remove_post;
+int HP_bg_team_join_pre;
+int HP_bg_team_join_post;
+int HP_bg_team_leave_pre;
+int HP_bg_team_leave_post;
+int HP_bg_member_respawn_pre;
+int HP_bg_member_respawn_post;
+int HP_bg_create_pre;
+int HP_bg_create_post;
+int HP_bg_team_get_id_pre;
+int HP_bg_team_get_id_post;
+int HP_bg_send_message_pre;
+int HP_bg_send_message_post;
+int HP_bg_send_xy_timer_sub_pre;
+int HP_bg_send_xy_timer_sub_post;
+int HP_bg_send_xy_timer_pre;
+int HP_bg_send_xy_timer_post;
+int HP_bg_config_read_pre;
+int HP_bg_config_read_post;
+int HP_buyingstore_setup_pre;
+int HP_buyingstore_setup_post;
+int HP_buyingstore_create_pre;
+int HP_buyingstore_create_post;
+int HP_buyingstore_close_pre;
+int HP_buyingstore_close_post;
+int HP_buyingstore_open_pre;
+int HP_buyingstore_open_post;
+int HP_buyingstore_trade_pre;
+int HP_buyingstore_trade_post;
+int HP_buyingstore_search_pre;
+int HP_buyingstore_search_post;
+int HP_buyingstore_searchall_pre;
+int HP_buyingstore_searchall_post;
+int HP_buyingstore_getuid_pre;
+int HP_buyingstore_getuid_post;
+int HP_chat_create_pc_chat_pre;
+int HP_chat_create_pc_chat_post;
+int HP_chat_join_pre;
+int HP_chat_join_post;
+int HP_chat_leave_pre;
+int HP_chat_leave_post;
+int HP_chat_change_owner_pre;
+int HP_chat_change_owner_post;
+int HP_chat_change_status_pre;
+int HP_chat_change_status_post;
+int HP_chat_kick_pre;
+int HP_chat_kick_post;
+int HP_chat_create_npc_chat_pre;
+int HP_chat_create_npc_chat_post;
+int HP_chat_delete_npc_chat_pre;
+int HP_chat_delete_npc_chat_post;
+int HP_chat_enable_event_pre;
+int HP_chat_enable_event_post;
+int HP_chat_disable_event_pre;
+int HP_chat_disable_event_post;
+int HP_chat_npc_kick_all_pre;
+int HP_chat_npc_kick_all_post;
+int HP_chat_trigger_event_pre;
+int HP_chat_trigger_event_post;
+int HP_chat_create_pre;
+int HP_chat_create_post;
+int HP_chrif_final_pre;
+int HP_chrif_final_post;
+int HP_chrif_init_pre;
+int HP_chrif_init_post;
+int HP_chrif_setuserid_pre;
+int HP_chrif_setuserid_post;
+int HP_chrif_setpasswd_pre;
+int HP_chrif_setpasswd_post;
+int HP_chrif_checkdefaultlogin_pre;
+int HP_chrif_checkdefaultlogin_post;
+int HP_chrif_setip_pre;
+int HP_chrif_setip_post;
+int HP_chrif_setport_pre;
+int HP_chrif_setport_post;
+int HP_chrif_isconnected_pre;
+int HP_chrif_isconnected_post;
+int HP_chrif_check_shutdown_pre;
+int HP_chrif_check_shutdown_post;
+int HP_chrif_search_pre;
+int HP_chrif_search_post;
+int HP_chrif_auth_check_pre;
+int HP_chrif_auth_check_post;
+int HP_chrif_auth_delete_pre;
+int HP_chrif_auth_delete_post;
+int HP_chrif_auth_finished_pre;
+int HP_chrif_auth_finished_post;
+int HP_chrif_authreq_pre;
+int HP_chrif_authreq_post;
+int HP_chrif_authok_pre;
+int HP_chrif_authok_post;
+int HP_chrif_scdata_request_pre;
+int HP_chrif_scdata_request_post;
+int HP_chrif_save_pre;
+int HP_chrif_save_post;
+int HP_chrif_charselectreq_pre;
+int HP_chrif_charselectreq_post;
+int HP_chrif_changemapserver_pre;
+int HP_chrif_changemapserver_post;
+int HP_chrif_searchcharid_pre;
+int HP_chrif_searchcharid_post;
+int HP_chrif_changeemail_pre;
+int HP_chrif_changeemail_post;
+int HP_chrif_char_ask_name_pre;
+int HP_chrif_char_ask_name_post;
+int HP_chrif_updatefamelist_pre;
+int HP_chrif_updatefamelist_post;
+int HP_chrif_buildfamelist_pre;
+int HP_chrif_buildfamelist_post;
+int HP_chrif_save_scdata_pre;
+int HP_chrif_save_scdata_post;
+int HP_chrif_ragsrvinfo_pre;
+int HP_chrif_ragsrvinfo_post;
+int HP_chrif_char_offline_pre;
+int HP_chrif_char_offline_post;
+int HP_chrif_char_offline_nsd_pre;
+int HP_chrif_char_offline_nsd_post;
+int HP_chrif_char_reset_offline_pre;
+int HP_chrif_char_reset_offline_post;
+int HP_chrif_send_users_tochar_pre;
+int HP_chrif_send_users_tochar_post;
+int HP_chrif_char_online_pre;
+int HP_chrif_char_online_post;
+int HP_chrif_changesex_pre;
+int HP_chrif_changesex_post;
+int HP_chrif_divorce_pre;
+int HP_chrif_divorce_post;
+int HP_chrif_removefriend_pre;
+int HP_chrif_removefriend_post;
+int HP_chrif_send_report_pre;
+int HP_chrif_send_report_post;
+int HP_chrif_flush_fifo_pre;
+int HP_chrif_flush_fifo_post;
+int HP_chrif_skillid2idx_pre;
+int HP_chrif_skillid2idx_post;
+int HP_chrif_sd_to_auth_pre;
+int HP_chrif_sd_to_auth_post;
+int HP_chrif_check_connect_char_server_pre;
+int HP_chrif_check_connect_char_server_post;
+int HP_chrif_auth_logout_pre;
+int HP_chrif_auth_logout_post;
+int HP_chrif_save_ack_pre;
+int HP_chrif_save_ack_post;
+int HP_chrif_reconnect_pre;
+int HP_chrif_reconnect_post;
+int HP_chrif_auth_db_cleanup_sub_pre;
+int HP_chrif_auth_db_cleanup_sub_post;
+int HP_chrif_char_ask_name_answer_pre;
+int HP_chrif_char_ask_name_answer_post;
+int HP_chrif_auth_db_final_pre;
+int HP_chrif_auth_db_final_post;
+int HP_chrif_send_usercount_tochar_pre;
+int HP_chrif_send_usercount_tochar_post;
+int HP_chrif_auth_db_cleanup_pre;
+int HP_chrif_auth_db_cleanup_post;
+int HP_chrif_connect_pre;
+int HP_chrif_connect_post;
+int HP_chrif_connectack_pre;
+int HP_chrif_connectack_post;
+int HP_chrif_sendmap_pre;
+int HP_chrif_sendmap_post;
+int HP_chrif_sendmapack_pre;
+int HP_chrif_sendmapack_post;
+int HP_chrif_recvmap_pre;
+int HP_chrif_recvmap_post;
+int HP_chrif_changemapserverack_pre;
+int HP_chrif_changemapserverack_post;
+int HP_chrif_changedsex_pre;
+int HP_chrif_changedsex_post;
+int HP_chrif_divorceack_pre;
+int HP_chrif_divorceack_post;
+int HP_chrif_accountban_pre;
+int HP_chrif_accountban_post;
+int HP_chrif_recvfamelist_pre;
+int HP_chrif_recvfamelist_post;
+int HP_chrif_load_scdata_pre;
+int HP_chrif_load_scdata_post;
+int HP_chrif_update_ip_pre;
+int HP_chrif_update_ip_post;
+int HP_chrif_disconnectplayer_pre;
+int HP_chrif_disconnectplayer_post;
+int HP_chrif_removemap_pre;
+int HP_chrif_removemap_post;
+int HP_chrif_updatefamelist_ack_pre;
+int HP_chrif_updatefamelist_ack_post;
+int HP_chrif_keepalive_pre;
+int HP_chrif_keepalive_post;
+int HP_chrif_keepalive_ack_pre;
+int HP_chrif_keepalive_ack_post;
+int HP_chrif_deadopt_pre;
+int HP_chrif_deadopt_post;
+int HP_chrif_authfail_pre;
+int HP_chrif_authfail_post;
+int HP_chrif_on_ready_pre;
+int HP_chrif_on_ready_post;
+int HP_chrif_on_disconnect_pre;
+int HP_chrif_on_disconnect_post;
+int HP_chrif_parse_pre;
+int HP_chrif_parse_post;
+int HP_clif_init_pre;
+int HP_clif_init_post;
+int HP_clif_final_pre;
+int HP_clif_final_post;
+int HP_clif_setip_pre;
+int HP_clif_setip_post;
+int HP_clif_setbindip_pre;
+int HP_clif_setbindip_post;
+int HP_clif_setport_pre;
+int HP_clif_setport_post;
+int HP_clif_refresh_ip_pre;
+int HP_clif_refresh_ip_post;
+int HP_clif_send_pre;
+int HP_clif_send_post;
+int HP_clif_send_sub_pre;
+int HP_clif_send_sub_post;
+int HP_clif_parse_pre;
+int HP_clif_parse_post;
+int HP_clif_parse_cmd_pre;
+int HP_clif_parse_cmd_post;
+int HP_clif_decrypt_cmd_pre;
+int HP_clif_decrypt_cmd_post;
+int HP_clif_authok_pre;
+int HP_clif_authok_post;
+int HP_clif_authrefuse_pre;
+int HP_clif_authrefuse_post;
+int HP_clif_authfail_fd_pre;
+int HP_clif_authfail_fd_post;
+int HP_clif_charselectok_pre;
+int HP_clif_charselectok_post;
+int HP_clif_dropflooritem_pre;
+int HP_clif_dropflooritem_post;
+int HP_clif_clearflooritem_pre;
+int HP_clif_clearflooritem_post;
+int HP_clif_additem_pre;
+int HP_clif_additem_post;
+int HP_clif_dropitem_pre;
+int HP_clif_dropitem_post;
+int HP_clif_delitem_pre;
+int HP_clif_delitem_post;
+int HP_clif_takeitem_pre;
+int HP_clif_takeitem_post;
+int HP_clif_arrowequip_pre;
+int HP_clif_arrowequip_post;
+int HP_clif_arrow_fail_pre;
+int HP_clif_arrow_fail_post;
+int HP_clif_use_card_pre;
+int HP_clif_use_card_post;
+int HP_clif_cart_additem_pre;
+int HP_clif_cart_additem_post;
+int HP_clif_cart_delitem_pre;
+int HP_clif_cart_delitem_post;
+int HP_clif_equipitemack_pre;
+int HP_clif_equipitemack_post;
+int HP_clif_unequipitemack_pre;
+int HP_clif_unequipitemack_post;
+int HP_clif_useitemack_pre;
+int HP_clif_useitemack_post;
+int HP_clif_addcards_pre;
+int HP_clif_addcards_post;
+int HP_clif_addcards2_pre;
+int HP_clif_addcards2_post;
+int HP_clif_item_sub_pre;
+int HP_clif_item_sub_post;
+int HP_clif_getareachar_item_pre;
+int HP_clif_getareachar_item_post;
+int HP_clif_cart_additem_ack_pre;
+int HP_clif_cart_additem_ack_post;
+int HP_clif_cashshop_load_pre;
+int HP_clif_cashshop_load_post;
+int HP_clif_package_announce_pre;
+int HP_clif_package_announce_post;
+int HP_clif_clearunit_single_pre;
+int HP_clif_clearunit_single_post;
+int HP_clif_clearunit_area_pre;
+int HP_clif_clearunit_area_post;
+int HP_clif_clearunit_delayed_pre;
+int HP_clif_clearunit_delayed_post;
+int HP_clif_walkok_pre;
+int HP_clif_walkok_post;
+int HP_clif_move_pre;
+int HP_clif_move_post;
+int HP_clif_move2_pre;
+int HP_clif_move2_post;
+int HP_clif_blown_pre;
+int HP_clif_blown_post;
+int HP_clif_slide_pre;
+int HP_clif_slide_post;
+int HP_clif_fixpos_pre;
+int HP_clif_fixpos_post;
+int HP_clif_changelook_pre;
+int HP_clif_changelook_post;
+int HP_clif_changetraplook_pre;
+int HP_clif_changetraplook_post;
+int HP_clif_refreshlook_pre;
+int HP_clif_refreshlook_post;
+int HP_clif_class_change_pre;
+int HP_clif_class_change_post;
+int HP_clif_skill_setunit_pre;
+int HP_clif_skill_setunit_post;
+int HP_clif_skill_delunit_pre;
+int HP_clif_skill_delunit_post;
+int HP_clif_skillunit_update_pre;
+int HP_clif_skillunit_update_post;
+int HP_clif_clearunit_delayed_sub_pre;
+int HP_clif_clearunit_delayed_sub_post;
+int HP_clif_set_unit_idle_pre;
+int HP_clif_set_unit_idle_post;
+int HP_clif_spawn_unit_pre;
+int HP_clif_spawn_unit_post;
+int HP_clif_set_unit_walking_pre;
+int HP_clif_set_unit_walking_post;
+int HP_clif_calc_walkdelay_pre;
+int HP_clif_calc_walkdelay_post;
+int HP_clif_getareachar_skillunit_pre;
+int HP_clif_getareachar_skillunit_post;
+int HP_clif_getareachar_unit_pre;
+int HP_clif_getareachar_unit_post;
+int HP_clif_clearchar_skillunit_pre;
+int HP_clif_clearchar_skillunit_post;
+int HP_clif_getareachar_pre;
+int HP_clif_getareachar_post;
+int HP_clif_spawn_pre;
+int HP_clif_spawn_post;
+int HP_clif_changemap_pre;
+int HP_clif_changemap_post;
+int HP_clif_changemapcell_pre;
+int HP_clif_changemapcell_post;
+int HP_clif_map_property_pre;
+int HP_clif_map_property_post;
+int HP_clif_pvpset_pre;
+int HP_clif_pvpset_post;
+int HP_clif_map_property_mapall_pre;
+int HP_clif_map_property_mapall_post;
+int HP_clif_bossmapinfo_pre;
+int HP_clif_bossmapinfo_post;
+int HP_clif_map_type_pre;
+int HP_clif_map_type_post;
+int HP_clif_maptypeproperty2_pre;
+int HP_clif_maptypeproperty2_post;
+int HP_clif_changemapserver_pre;
+int HP_clif_changemapserver_post;
+int HP_clif_npcbuysell_pre;
+int HP_clif_npcbuysell_post;
+int HP_clif_buylist_pre;
+int HP_clif_buylist_post;
+int HP_clif_selllist_pre;
+int HP_clif_selllist_post;
+int HP_clif_cashshop_show_pre;
+int HP_clif_cashshop_show_post;
+int HP_clif_npc_buy_result_pre;
+int HP_clif_npc_buy_result_post;
+int HP_clif_npc_sell_result_pre;
+int HP_clif_npc_sell_result_post;
+int HP_clif_cashshop_ack_pre;
+int HP_clif_cashshop_ack_post;
+int HP_clif_scriptmes_pre;
+int HP_clif_scriptmes_post;
+int HP_clif_scriptnext_pre;
+int HP_clif_scriptnext_post;
+int HP_clif_scriptclose_pre;
+int HP_clif_scriptclose_post;
+int HP_clif_scriptmenu_pre;
+int HP_clif_scriptmenu_post;
+int HP_clif_scriptinput_pre;
+int HP_clif_scriptinput_post;
+int HP_clif_scriptinputstr_pre;
+int HP_clif_scriptinputstr_post;
+int HP_clif_cutin_pre;
+int HP_clif_cutin_post;
+int HP_clif_sendfakenpc_pre;
+int HP_clif_sendfakenpc_post;
+int HP_clif_scriptclear_pre;
+int HP_clif_scriptclear_post;
+int HP_clif_viewpoint_pre;
+int HP_clif_viewpoint_post;
+int HP_clif_damage_pre;
+int HP_clif_damage_post;
+int HP_clif_sitting_pre;
+int HP_clif_sitting_post;
+int HP_clif_standing_pre;
+int HP_clif_standing_post;
+int HP_clif_arrow_create_list_pre;
+int HP_clif_arrow_create_list_post;
+int HP_clif_refresh_pre;
+int HP_clif_refresh_post;
+int HP_clif_fame_blacksmith_pre;
+int HP_clif_fame_blacksmith_post;
+int HP_clif_fame_alchemist_pre;
+int HP_clif_fame_alchemist_post;
+int HP_clif_fame_taekwon_pre;
+int HP_clif_fame_taekwon_post;
+int HP_clif_ranklist_pre;
+int HP_clif_ranklist_post;
+int HP_clif_update_rankingpoint_pre;
+int HP_clif_update_rankingpoint_post;
+int HP_clif_pRanklist_pre;
+int HP_clif_pRanklist_post;
+int HP_clif_hotkeys_pre;
+int HP_clif_hotkeys_post;
+int HP_clif_insight_pre;
+int HP_clif_insight_post;
+int HP_clif_outsight_pre;
+int HP_clif_outsight_post;
+int HP_clif_skillcastcancel_pre;
+int HP_clif_skillcastcancel_post;
+int HP_clif_skill_fail_pre;
+int HP_clif_skill_fail_post;
+int HP_clif_skill_cooldown_pre;
+int HP_clif_skill_cooldown_post;
+int HP_clif_skill_memomessage_pre;
+int HP_clif_skill_memomessage_post;
+int HP_clif_skill_mapinfomessage_pre;
+int HP_clif_skill_mapinfomessage_post;
+int HP_clif_skill_produce_mix_list_pre;
+int HP_clif_skill_produce_mix_list_post;
+int HP_clif_cooking_list_pre;
+int HP_clif_cooking_list_post;
+int HP_clif_autospell_pre;
+int HP_clif_autospell_post;
+int HP_clif_combo_delay_pre;
+int HP_clif_combo_delay_post;
+int HP_clif_status_change_pre;
+int HP_clif_status_change_post;
+int HP_clif_insert_card_pre;
+int HP_clif_insert_card_post;
+int HP_clif_inventorylist_pre;
+int HP_clif_inventorylist_post;
+int HP_clif_equiplist_pre;
+int HP_clif_equiplist_post;
+int HP_clif_cartlist_pre;
+int HP_clif_cartlist_post;
+int HP_clif_favorite_item_pre;
+int HP_clif_favorite_item_post;
+int HP_clif_clearcart_pre;
+int HP_clif_clearcart_post;
+int HP_clif_item_identify_list_pre;
+int HP_clif_item_identify_list_post;
+int HP_clif_item_identified_pre;
+int HP_clif_item_identified_post;
+int HP_clif_item_repair_list_pre;
+int HP_clif_item_repair_list_post;
+int HP_clif_item_repaireffect_pre;
+int HP_clif_item_repaireffect_post;
+int HP_clif_item_damaged_pre;
+int HP_clif_item_damaged_post;
+int HP_clif_item_refine_list_pre;
+int HP_clif_item_refine_list_post;
+int HP_clif_item_skill_pre;
+int HP_clif_item_skill_post;
+int HP_clif_mvp_item_pre;
+int HP_clif_mvp_item_post;
+int HP_clif_mvp_exp_pre;
+int HP_clif_mvp_exp_post;
+int HP_clif_mvp_noitem_pre;
+int HP_clif_mvp_noitem_post;
+int HP_clif_changed_dir_pre;
+int HP_clif_changed_dir_post;
+int HP_clif_charnameack_pre;
+int HP_clif_charnameack_post;
+int HP_clif_monster_hp_bar_pre;
+int HP_clif_monster_hp_bar_post;
+int HP_clif_hpmeter_pre;
+int HP_clif_hpmeter_post;
+int HP_clif_hpmeter_single_pre;
+int HP_clif_hpmeter_single_post;
+int HP_clif_hpmeter_sub_pre;
+int HP_clif_hpmeter_sub_post;
+int HP_clif_upgrademessage_pre;
+int HP_clif_upgrademessage_post;
+int HP_clif_get_weapon_view_pre;
+int HP_clif_get_weapon_view_post;
+int HP_clif_gospel_info_pre;
+int HP_clif_gospel_info_post;
+int HP_clif_feel_req_pre;
+int HP_clif_feel_req_post;
+int HP_clif_starskill_pre;
+int HP_clif_starskill_post;
+int HP_clif_feel_info_pre;
+int HP_clif_feel_info_post;
+int HP_clif_hate_info_pre;
+int HP_clif_hate_info_post;
+int HP_clif_mission_info_pre;
+int HP_clif_mission_info_post;
+int HP_clif_feel_hate_reset_pre;
+int HP_clif_feel_hate_reset_post;
+int HP_clif_partytickack_pre;
+int HP_clif_partytickack_post;
+int HP_clif_equiptickack_pre;
+int HP_clif_equiptickack_post;
+int HP_clif_viewequip_ack_pre;
+int HP_clif_viewequip_ack_post;
+int HP_clif_viewequip_fail_pre;
+int HP_clif_viewequip_fail_post;
+int HP_clif_equpcheckbox_pre;
+int HP_clif_equpcheckbox_post;
+int HP_clif_displayexp_pre;
+int HP_clif_displayexp_post;
+int HP_clif_font_pre;
+int HP_clif_font_post;
+int HP_clif_progressbar_pre;
+int HP_clif_progressbar_post;
+int HP_clif_progressbar_abort_pre;
+int HP_clif_progressbar_abort_post;
+int HP_clif_showdigit_pre;
+int HP_clif_showdigit_post;
+int HP_clif_elementalconverter_list_pre;
+int HP_clif_elementalconverter_list_post;
+int HP_clif_spellbook_list_pre;
+int HP_clif_spellbook_list_post;
+int HP_clif_magicdecoy_list_pre;
+int HP_clif_magicdecoy_list_post;
+int HP_clif_poison_list_pre;
+int HP_clif_poison_list_post;
+int HP_clif_autoshadowspell_list_pre;
+int HP_clif_autoshadowspell_list_post;
+int HP_clif_skill_itemlistwindow_pre;
+int HP_clif_skill_itemlistwindow_post;
+int HP_clif_sc_load_pre;
+int HP_clif_sc_load_post;
+int HP_clif_sc_end_pre;
+int HP_clif_sc_end_post;
+int HP_clif_initialstatus_pre;
+int HP_clif_initialstatus_post;
+int HP_clif_cooldown_list_pre;
+int HP_clif_cooldown_list_post;
+int HP_clif_updatestatus_pre;
+int HP_clif_updatestatus_post;
+int HP_clif_changestatus_pre;
+int HP_clif_changestatus_post;
+int HP_clif_statusupack_pre;
+int HP_clif_statusupack_post;
+int HP_clif_movetoattack_pre;
+int HP_clif_movetoattack_post;
+int HP_clif_solved_charname_pre;
+int HP_clif_solved_charname_post;
+int HP_clif_charnameupdate_pre;
+int HP_clif_charnameupdate_post;
+int HP_clif_delayquit_pre;
+int HP_clif_delayquit_post;
+int HP_clif_getareachar_pc_pre;
+int HP_clif_getareachar_pc_post;
+int HP_clif_disconnect_ack_pre;
+int HP_clif_disconnect_ack_post;
+int HP_clif_PVPInfo_pre;
+int HP_clif_PVPInfo_post;
+int HP_clif_blacksmith_pre;
+int HP_clif_blacksmith_post;
+int HP_clif_alchemist_pre;
+int HP_clif_alchemist_post;
+int HP_clif_taekwon_pre;
+int HP_clif_taekwon_post;
+int HP_clif_ranking_pk_pre;
+int HP_clif_ranking_pk_post;
+int HP_clif_quitsave_pre;
+int HP_clif_quitsave_post;
+int HP_clif_misceffect_pre;
+int HP_clif_misceffect_post;
+int HP_clif_changeoption_pre;
+int HP_clif_changeoption_post;
+int HP_clif_changeoption2_pre;
+int HP_clif_changeoption2_post;
+int HP_clif_emotion_pre;
+int HP_clif_emotion_post;
+int HP_clif_talkiebox_pre;
+int HP_clif_talkiebox_post;
+int HP_clif_wedding_effect_pre;
+int HP_clif_wedding_effect_post;
+int HP_clif_divorced_pre;
+int HP_clif_divorced_post;
+int HP_clif_callpartner_pre;
+int HP_clif_callpartner_post;
+int HP_clif_skill_damage_pre;
+int HP_clif_skill_damage_post;
+int HP_clif_skill_nodamage_pre;
+int HP_clif_skill_nodamage_post;
+int HP_clif_skill_poseffect_pre;
+int HP_clif_skill_poseffect_post;
+int HP_clif_skill_estimation_pre;
+int HP_clif_skill_estimation_post;
+int HP_clif_skill_warppoint_pre;
+int HP_clif_skill_warppoint_post;
+int HP_clif_skillcasting_pre;
+int HP_clif_skillcasting_post;
+int HP_clif_produce_effect_pre;
+int HP_clif_produce_effect_post;
+int HP_clif_devotion_pre;
+int HP_clif_devotion_post;
+int HP_clif_spiritball_pre;
+int HP_clif_spiritball_post;
+int HP_clif_spiritball_single_pre;
+int HP_clif_spiritball_single_post;
+int HP_clif_bladestop_pre;
+int HP_clif_bladestop_post;
+int HP_clif_mvp_effect_pre;
+int HP_clif_mvp_effect_post;
+int HP_clif_heal_pre;
+int HP_clif_heal_post;
+int HP_clif_resurrection_pre;
+int HP_clif_resurrection_post;
+int HP_clif_refine_pre;
+int HP_clif_refine_post;
+int HP_clif_weather_pre;
+int HP_clif_weather_post;
+int HP_clif_specialeffect_pre;
+int HP_clif_specialeffect_post;
+int HP_clif_specialeffect_single_pre;
+int HP_clif_specialeffect_single_post;
+int HP_clif_specialeffect_value_pre;
+int HP_clif_specialeffect_value_post;
+int HP_clif_millenniumshield_pre;
+int HP_clif_millenniumshield_post;
+int HP_clif_charm_pre;
+int HP_clif_charm_post;
+int HP_clif_charm_single_pre;
+int HP_clif_charm_single_post;
+int HP_clif_snap_pre;
+int HP_clif_snap_post;
+int HP_clif_weather_check_pre;
+int HP_clif_weather_check_post;
+int HP_clif_playBGM_pre;
+int HP_clif_playBGM_post;
+int HP_clif_soundeffect_pre;
+int HP_clif_soundeffect_post;
+int HP_clif_soundeffectall_pre;
+int HP_clif_soundeffectall_post;
+int HP_clif_GlobalMessage_pre;
+int HP_clif_GlobalMessage_post;
+int HP_clif_createchat_pre;
+int HP_clif_createchat_post;
+int HP_clif_dispchat_pre;
+int HP_clif_dispchat_post;
+int HP_clif_joinchatfail_pre;
+int HP_clif_joinchatfail_post;
+int HP_clif_joinchatok_pre;
+int HP_clif_joinchatok_post;
+int HP_clif_addchat_pre;
+int HP_clif_addchat_post;
+int HP_clif_changechatowner_pre;
+int HP_clif_changechatowner_post;
+int HP_clif_clearchat_pre;
+int HP_clif_clearchat_post;
+int HP_clif_leavechat_pre;
+int HP_clif_leavechat_post;
+int HP_clif_changechatstatus_pre;
+int HP_clif_changechatstatus_post;
+int HP_clif_wis_message_pre;
+int HP_clif_wis_message_post;
+int HP_clif_wis_end_pre;
+int HP_clif_wis_end_post;
+int HP_clif_disp_onlyself_pre;
+int HP_clif_disp_onlyself_post;
+int HP_clif_disp_message_pre;
+int HP_clif_disp_message_post;
+int HP_clif_broadcast_pre;
+int HP_clif_broadcast_post;
+int HP_clif_broadcast2_pre;
+int HP_clif_broadcast2_post;
+int HP_clif_messagecolor_pre;
+int HP_clif_messagecolor_post;
+int HP_clif_disp_overhead_pre;
+int HP_clif_disp_overhead_post;
+int HP_clif_msg_pre;
+int HP_clif_msg_post;
+int HP_clif_msg_value_pre;
+int HP_clif_msg_value_post;
+int HP_clif_msg_skill_pre;
+int HP_clif_msg_skill_post;
+int HP_clif_msgtable_pre;
+int HP_clif_msgtable_post;
+int HP_clif_msgtable_num_pre;
+int HP_clif_msgtable_num_post;
+int HP_clif_message_pre;
+int HP_clif_message_post;
+int HP_clif_messageln_pre;
+int HP_clif_messageln_post;
+int HP_clif_colormes_pre;
+int HP_clif_colormes_post;
+int HP_clif_process_message_pre;
+int HP_clif_process_message_post;
+int HP_clif_wisexin_pre;
+int HP_clif_wisexin_post;
+int HP_clif_wisall_pre;
+int HP_clif_wisall_post;
+int HP_clif_PMIgnoreList_pre;
+int HP_clif_PMIgnoreList_post;
+int HP_clif_traderequest_pre;
+int HP_clif_traderequest_post;
+int HP_clif_tradestart_pre;
+int HP_clif_tradestart_post;
+int HP_clif_tradeadditem_pre;
+int HP_clif_tradeadditem_post;
+int HP_clif_tradeitemok_pre;
+int HP_clif_tradeitemok_post;
+int HP_clif_tradedeal_lock_pre;
+int HP_clif_tradedeal_lock_post;
+int HP_clif_tradecancelled_pre;
+int HP_clif_tradecancelled_post;
+int HP_clif_tradecompleted_pre;
+int HP_clif_tradecompleted_post;
+int HP_clif_tradeundo_pre;
+int HP_clif_tradeundo_post;
+int HP_clif_openvendingreq_pre;
+int HP_clif_openvendingreq_post;
+int HP_clif_showvendingboard_pre;
+int HP_clif_showvendingboard_post;
+int HP_clif_closevendingboard_pre;
+int HP_clif_closevendingboard_post;
+int HP_clif_vendinglist_pre;
+int HP_clif_vendinglist_post;
+int HP_clif_buyvending_pre;
+int HP_clif_buyvending_post;
+int HP_clif_openvending_pre;
+int HP_clif_openvending_post;
+int HP_clif_vendingreport_pre;
+int HP_clif_vendingreport_post;
+int HP_clif_storagelist_pre;
+int HP_clif_storagelist_post;
+int HP_clif_updatestorageamount_pre;
+int HP_clif_updatestorageamount_post;
+int HP_clif_storageitemadded_pre;
+int HP_clif_storageitemadded_post;
+int HP_clif_storageitemremoved_pre;
+int HP_clif_storageitemremoved_post;
+int HP_clif_storageclose_pre;
+int HP_clif_storageclose_post;
+int HP_clif_skillinfoblock_pre;
+int HP_clif_skillinfoblock_post;
+int HP_clif_skillup_pre;
+int HP_clif_skillup_post;
+int HP_clif_skillinfo_pre;
+int HP_clif_skillinfo_post;
+int HP_clif_addskill_pre;
+int HP_clif_addskill_post;
+int HP_clif_deleteskill_pre;
+int HP_clif_deleteskill_post;
+int HP_clif_party_created_pre;
+int HP_clif_party_created_post;
+int HP_clif_party_member_info_pre;
+int HP_clif_party_member_info_post;
+int HP_clif_party_info_pre;
+int HP_clif_party_info_post;
+int HP_clif_party_invite_pre;
+int HP_clif_party_invite_post;
+int HP_clif_party_inviteack_pre;
+int HP_clif_party_inviteack_post;
+int HP_clif_party_option_pre;
+int HP_clif_party_option_post;
+int HP_clif_party_withdraw_pre;
+int HP_clif_party_withdraw_post;
+int HP_clif_party_message_pre;
+int HP_clif_party_message_post;
+int HP_clif_party_xy_pre;
+int HP_clif_party_xy_post;
+int HP_clif_party_xy_single_pre;
+int HP_clif_party_xy_single_post;
+int HP_clif_party_hp_pre;
+int HP_clif_party_hp_post;
+int HP_clif_party_xy_remove_pre;
+int HP_clif_party_xy_remove_post;
+int HP_clif_party_show_picker_pre;
+int HP_clif_party_show_picker_post;
+int HP_clif_partyinvitationstate_pre;
+int HP_clif_partyinvitationstate_post;
+int HP_clif_guild_created_pre;
+int HP_clif_guild_created_post;
+int HP_clif_guild_belonginfo_pre;
+int HP_clif_guild_belonginfo_post;
+int HP_clif_guild_masterormember_pre;
+int HP_clif_guild_masterormember_post;
+int HP_clif_guild_basicinfo_pre;
+int HP_clif_guild_basicinfo_post;
+int HP_clif_guild_allianceinfo_pre;
+int HP_clif_guild_allianceinfo_post;
+int HP_clif_guild_memberlist_pre;
+int HP_clif_guild_memberlist_post;
+int HP_clif_guild_skillinfo_pre;
+int HP_clif_guild_skillinfo_post;
+int HP_clif_guild_send_onlineinfo_pre;
+int HP_clif_guild_send_onlineinfo_post;
+int HP_clif_guild_memberlogin_notice_pre;
+int HP_clif_guild_memberlogin_notice_post;
+int HP_clif_guild_invite_pre;
+int HP_clif_guild_invite_post;
+int HP_clif_guild_inviteack_pre;
+int HP_clif_guild_inviteack_post;
+int HP_clif_guild_leave_pre;
+int HP_clif_guild_leave_post;
+int HP_clif_guild_expulsion_pre;
+int HP_clif_guild_expulsion_post;
+int HP_clif_guild_positionchanged_pre;
+int HP_clif_guild_positionchanged_post;
+int HP_clif_guild_memberpositionchanged_pre;
+int HP_clif_guild_memberpositionchanged_post;
+int HP_clif_guild_emblem_pre;
+int HP_clif_guild_emblem_post;
+int HP_clif_guild_emblem_area_pre;
+int HP_clif_guild_emblem_area_post;
+int HP_clif_guild_notice_pre;
+int HP_clif_guild_notice_post;
+int HP_clif_guild_message_pre;
+int HP_clif_guild_message_post;
+int HP_clif_guild_skillup_pre;
+int HP_clif_guild_skillup_post;
+int HP_clif_guild_reqalliance_pre;
+int HP_clif_guild_reqalliance_post;
+int HP_clif_guild_allianceack_pre;
+int HP_clif_guild_allianceack_post;
+int HP_clif_guild_delalliance_pre;
+int HP_clif_guild_delalliance_post;
+int HP_clif_guild_oppositionack_pre;
+int HP_clif_guild_oppositionack_post;
+int HP_clif_guild_broken_pre;
+int HP_clif_guild_broken_post;
+int HP_clif_guild_xy_pre;
+int HP_clif_guild_xy_post;
+int HP_clif_guild_xy_single_pre;
+int HP_clif_guild_xy_single_post;
+int HP_clif_guild_xy_remove_pre;
+int HP_clif_guild_xy_remove_post;
+int HP_clif_guild_positionnamelist_pre;
+int HP_clif_guild_positionnamelist_post;
+int HP_clif_guild_positioninfolist_pre;
+int HP_clif_guild_positioninfolist_post;
+int HP_clif_guild_expulsionlist_pre;
+int HP_clif_guild_expulsionlist_post;
+int HP_clif_validate_emblem_pre;
+int HP_clif_validate_emblem_post;
+int HP_clif_bg_hp_pre;
+int HP_clif_bg_hp_post;
+int HP_clif_bg_xy_pre;
+int HP_clif_bg_xy_post;
+int HP_clif_bg_xy_remove_pre;
+int HP_clif_bg_xy_remove_post;
+int HP_clif_bg_message_pre;
+int HP_clif_bg_message_post;
+int HP_clif_bg_updatescore_pre;
+int HP_clif_bg_updatescore_post;
+int HP_clif_bg_updatescore_single_pre;
+int HP_clif_bg_updatescore_single_post;
+int HP_clif_sendbgemblem_area_pre;
+int HP_clif_sendbgemblem_area_post;
+int HP_clif_sendbgemblem_single_pre;
+int HP_clif_sendbgemblem_single_post;
+int HP_clif_instance_pre;
+int HP_clif_instance_post;
+int HP_clif_instance_join_pre;
+int HP_clif_instance_join_post;
+int HP_clif_instance_leave_pre;
+int HP_clif_instance_leave_post;
+int HP_clif_catch_process_pre;
+int HP_clif_catch_process_post;
+int HP_clif_pet_roulette_pre;
+int HP_clif_pet_roulette_post;
+int HP_clif_sendegg_pre;
+int HP_clif_sendegg_post;
+int HP_clif_send_petstatus_pre;
+int HP_clif_send_petstatus_post;
+int HP_clif_send_petdata_pre;
+int HP_clif_send_petdata_post;
+int HP_clif_pet_emotion_pre;
+int HP_clif_pet_emotion_post;
+int HP_clif_pet_food_pre;
+int HP_clif_pet_food_post;
+int HP_clif_friendslist_toggle_sub_pre;
+int HP_clif_friendslist_toggle_sub_post;
+int HP_clif_friendslist_send_pre;
+int HP_clif_friendslist_send_post;
+int HP_clif_friendslist_reqack_pre;
+int HP_clif_friendslist_reqack_post;
+int HP_clif_friendslist_toggle_pre;
+int HP_clif_friendslist_toggle_post;
+int HP_clif_friendlist_req_pre;
+int HP_clif_friendlist_req_post;
+int HP_clif_GM_kickack_pre;
+int HP_clif_GM_kickack_post;
+int HP_clif_GM_kick_pre;
+int HP_clif_GM_kick_post;
+int HP_clif_manner_message_pre;
+int HP_clif_manner_message_post;
+int HP_clif_GM_silence_pre;
+int HP_clif_GM_silence_post;
+int HP_clif_account_name_pre;
+int HP_clif_account_name_post;
+int HP_clif_check_pre;
+int HP_clif_check_post;
+int HP_clif_hominfo_pre;
+int HP_clif_hominfo_post;
+int HP_clif_homskillinfoblock_pre;
+int HP_clif_homskillinfoblock_post;
+int HP_clif_homskillup_pre;
+int HP_clif_homskillup_post;
+int HP_clif_hom_food_pre;
+int HP_clif_hom_food_post;
+int HP_clif_send_homdata_pre;
+int HP_clif_send_homdata_post;
+int HP_clif_quest_send_list_pre;
+int HP_clif_quest_send_list_post;
+int HP_clif_quest_send_mission_pre;
+int HP_clif_quest_send_mission_post;
+int HP_clif_quest_add_pre;
+int HP_clif_quest_add_post;
+int HP_clif_quest_delete_pre;
+int HP_clif_quest_delete_post;
+int HP_clif_quest_update_status_pre;
+int HP_clif_quest_update_status_post;
+int HP_clif_quest_update_objective_pre;
+int HP_clif_quest_update_objective_post;
+int HP_clif_quest_show_event_pre;
+int HP_clif_quest_show_event_post;
+int HP_clif_mail_window_pre;
+int HP_clif_mail_window_post;
+int HP_clif_mail_read_pre;
+int HP_clif_mail_read_post;
+int HP_clif_mail_delete_pre;
+int HP_clif_mail_delete_post;
+int HP_clif_mail_return_pre;
+int HP_clif_mail_return_post;
+int HP_clif_mail_send_pre;
+int HP_clif_mail_send_post;
+int HP_clif_mail_new_pre;
+int HP_clif_mail_new_post;
+int HP_clif_mail_refreshinbox_pre;
+int HP_clif_mail_refreshinbox_post;
+int HP_clif_mail_getattachment_pre;
+int HP_clif_mail_getattachment_post;
+int HP_clif_mail_setattachment_pre;
+int HP_clif_mail_setattachment_post;
+int HP_clif_auction_openwindow_pre;
+int HP_clif_auction_openwindow_post;
+int HP_clif_auction_results_pre;
+int HP_clif_auction_results_post;
+int HP_clif_auction_message_pre;
+int HP_clif_auction_message_post;
+int HP_clif_auction_close_pre;
+int HP_clif_auction_close_post;
+int HP_clif_auction_setitem_pre;
+int HP_clif_auction_setitem_post;
+int HP_clif_mercenary_info_pre;
+int HP_clif_mercenary_info_post;
+int HP_clif_mercenary_skillblock_pre;
+int HP_clif_mercenary_skillblock_post;
+int HP_clif_mercenary_message_pre;
+int HP_clif_mercenary_message_post;
+int HP_clif_mercenary_updatestatus_pre;
+int HP_clif_mercenary_updatestatus_post;
+int HP_clif_rental_time_pre;
+int HP_clif_rental_time_post;
+int HP_clif_rental_expired_pre;
+int HP_clif_rental_expired_post;
+int HP_clif_PartyBookingRegisterAck_pre;
+int HP_clif_PartyBookingRegisterAck_post;
+int HP_clif_PartyBookingDeleteAck_pre;
+int HP_clif_PartyBookingDeleteAck_post;
+int HP_clif_PartyBookingSearchAck_pre;
+int HP_clif_PartyBookingSearchAck_post;
+int HP_clif_PartyBookingUpdateNotify_pre;
+int HP_clif_PartyBookingUpdateNotify_post;
+int HP_clif_PartyBookingDeleteNotify_pre;
+int HP_clif_PartyBookingDeleteNotify_post;
+int HP_clif_PartyBookingInsertNotify_pre;
+int HP_clif_PartyBookingInsertNotify_post;
+int HP_clif_PartyBookingVolunteerInfo_pre;
+int HP_clif_PartyBookingVolunteerInfo_post;
+int HP_clif_PartyBookingRefuseVolunteer_pre;
+int HP_clif_PartyBookingRefuseVolunteer_post;
+int HP_clif_PartyBookingCancelVolunteer_pre;
+int HP_clif_PartyBookingCancelVolunteer_post;
+int HP_clif_PartyBookingAddFilteringList_pre;
+int HP_clif_PartyBookingAddFilteringList_post;
+int HP_clif_PartyBookingSubFilteringList_pre;
+int HP_clif_PartyBookingSubFilteringList_post;
+int HP_clif_buyingstore_open_pre;
+int HP_clif_buyingstore_open_post;
+int HP_clif_buyingstore_open_failed_pre;
+int HP_clif_buyingstore_open_failed_post;
+int HP_clif_buyingstore_myitemlist_pre;
+int HP_clif_buyingstore_myitemlist_post;
+int HP_clif_buyingstore_entry_pre;
+int HP_clif_buyingstore_entry_post;
+int HP_clif_buyingstore_entry_single_pre;
+int HP_clif_buyingstore_entry_single_post;
+int HP_clif_buyingstore_disappear_entry_pre;
+int HP_clif_buyingstore_disappear_entry_post;
+int HP_clif_buyingstore_disappear_entry_single_pre;
+int HP_clif_buyingstore_disappear_entry_single_post;
+int HP_clif_buyingstore_itemlist_pre;
+int HP_clif_buyingstore_itemlist_post;
+int HP_clif_buyingstore_trade_failed_buyer_pre;
+int HP_clif_buyingstore_trade_failed_buyer_post;
+int HP_clif_buyingstore_update_item_pre;
+int HP_clif_buyingstore_update_item_post;
+int HP_clif_buyingstore_delete_item_pre;
+int HP_clif_buyingstore_delete_item_post;
+int HP_clif_buyingstore_trade_failed_seller_pre;
+int HP_clif_buyingstore_trade_failed_seller_post;
+int HP_clif_search_store_info_ack_pre;
+int HP_clif_search_store_info_ack_post;
+int HP_clif_search_store_info_failed_pre;
+int HP_clif_search_store_info_failed_post;
+int HP_clif_open_search_store_info_pre;
+int HP_clif_open_search_store_info_post;
+int HP_clif_search_store_info_click_ack_pre;
+int HP_clif_search_store_info_click_ack_post;
+int HP_clif_elemental_info_pre;
+int HP_clif_elemental_info_post;
+int HP_clif_elemental_updatestatus_pre;
+int HP_clif_elemental_updatestatus_post;
+int HP_clif_bgqueue_ack_pre;
+int HP_clif_bgqueue_ack_post;
+int HP_clif_bgqueue_notice_delete_pre;
+int HP_clif_bgqueue_notice_delete_post;
+int HP_clif_bgqueue_update_info_pre;
+int HP_clif_bgqueue_update_info_post;
+int HP_clif_bgqueue_joined_pre;
+int HP_clif_bgqueue_joined_post;
+int HP_clif_bgqueue_pcleft_pre;
+int HP_clif_bgqueue_pcleft_post;
+int HP_clif_bgqueue_battlebegins_pre;
+int HP_clif_bgqueue_battlebegins_post;
+int HP_clif_adopt_reply_pre;
+int HP_clif_adopt_reply_post;
+int HP_clif_adopt_request_pre;
+int HP_clif_adopt_request_post;
+int HP_clif_readbook_pre;
+int HP_clif_readbook_post;
+int HP_clif_notify_time_pre;
+int HP_clif_notify_time_post;
+int HP_clif_user_count_pre;
+int HP_clif_user_count_post;
+int HP_clif_noask_sub_pre;
+int HP_clif_noask_sub_post;
+int HP_clif_bc_ready_pre;
+int HP_clif_bc_ready_post;
+int HP_clif_undisguise_timer_pre;
+int HP_clif_undisguise_timer_post;
+int HP_clif_chsys_create_pre;
+int HP_clif_chsys_create_post;
+int HP_clif_chsys_msg_pre;
+int HP_clif_chsys_msg_post;
+int HP_clif_chsys_msg2_pre;
+int HP_clif_chsys_msg2_post;
+int HP_clif_chsys_send_pre;
+int HP_clif_chsys_send_post;
+int HP_clif_chsys_join_pre;
+int HP_clif_chsys_join_post;
+int HP_clif_chsys_left_pre;
+int HP_clif_chsys_left_post;
+int HP_clif_chsys_delete_pre;
+int HP_clif_chsys_delete_post;
+int HP_clif_chsys_mjoin_pre;
+int HP_clif_chsys_mjoin_post;
+int HP_clif_chsys_quit_pre;
+int HP_clif_chsys_quit_post;
+int HP_clif_chsys_quitg_pre;
+int HP_clif_chsys_quitg_post;
+int HP_clif_chsys_gjoin_pre;
+int HP_clif_chsys_gjoin_post;
+int HP_clif_chsys_gleave_pre;
+int HP_clif_chsys_gleave_post;
+int HP_clif_pWantToConnection_pre;
+int HP_clif_pWantToConnection_post;
+int HP_clif_pLoadEndAck_pre;
+int HP_clif_pLoadEndAck_post;
+int HP_clif_pTickSend_pre;
+int HP_clif_pTickSend_post;
+int HP_clif_pHotkey_pre;
+int HP_clif_pHotkey_post;
+int HP_clif_pProgressbar_pre;
+int HP_clif_pProgressbar_post;
+int HP_clif_pWalkToXY_pre;
+int HP_clif_pWalkToXY_post;
+int HP_clif_pQuitGame_pre;
+int HP_clif_pQuitGame_post;
+int HP_clif_pGetCharNameRequest_pre;
+int HP_clif_pGetCharNameRequest_post;
+int HP_clif_pGlobalMessage_pre;
+int HP_clif_pGlobalMessage_post;
+int HP_clif_pMapMove_pre;
+int HP_clif_pMapMove_post;
+int HP_clif_pChangeDir_pre;
+int HP_clif_pChangeDir_post;
+int HP_clif_pEmotion_pre;
+int HP_clif_pEmotion_post;
+int HP_clif_pHowManyConnections_pre;
+int HP_clif_pHowManyConnections_post;
+int HP_clif_pActionRequest_pre;
+int HP_clif_pActionRequest_post;
+int HP_clif_pActionRequest_sub_pre;
+int HP_clif_pActionRequest_sub_post;
+int HP_clif_pRestart_pre;
+int HP_clif_pRestart_post;
+int HP_clif_pWisMessage_pre;
+int HP_clif_pWisMessage_post;
+int HP_clif_pBroadcast_pre;
+int HP_clif_pBroadcast_post;
+int HP_clif_pTakeItem_pre;
+int HP_clif_pTakeItem_post;
+int HP_clif_pDropItem_pre;
+int HP_clif_pDropItem_post;
+int HP_clif_pUseItem_pre;
+int HP_clif_pUseItem_post;
+int HP_clif_pEquipItem_pre;
+int HP_clif_pEquipItem_post;
+int HP_clif_pUnequipItem_pre;
+int HP_clif_pUnequipItem_post;
+int HP_clif_pNpcClicked_pre;
+int HP_clif_pNpcClicked_post;
+int HP_clif_pNpcBuySellSelected_pre;
+int HP_clif_pNpcBuySellSelected_post;
+int HP_clif_pNpcBuyListSend_pre;
+int HP_clif_pNpcBuyListSend_post;
+int HP_clif_pNpcSellListSend_pre;
+int HP_clif_pNpcSellListSend_post;
+int HP_clif_pCreateChatRoom_pre;
+int HP_clif_pCreateChatRoom_post;
+int HP_clif_pChatAddMember_pre;
+int HP_clif_pChatAddMember_post;
+int HP_clif_pChatRoomStatusChange_pre;
+int HP_clif_pChatRoomStatusChange_post;
+int HP_clif_pChangeChatOwner_pre;
+int HP_clif_pChangeChatOwner_post;
+int HP_clif_pKickFromChat_pre;
+int HP_clif_pKickFromChat_post;
+int HP_clif_pChatLeave_pre;
+int HP_clif_pChatLeave_post;
+int HP_clif_pTradeRequest_pre;
+int HP_clif_pTradeRequest_post;
+int HP_clif_chann_config_read_pre;
+int HP_clif_chann_config_read_post;
+int HP_clif_pTradeAck_pre;
+int HP_clif_pTradeAck_post;
+int HP_clif_pTradeAddItem_pre;
+int HP_clif_pTradeAddItem_post;
+int HP_clif_pTradeOk_pre;
+int HP_clif_pTradeOk_post;
+int HP_clif_pTradeCancel_pre;
+int HP_clif_pTradeCancel_post;
+int HP_clif_pTradeCommit_pre;
+int HP_clif_pTradeCommit_post;
+int HP_clif_pStopAttack_pre;
+int HP_clif_pStopAttack_post;
+int HP_clif_pPutItemToCart_pre;
+int HP_clif_pPutItemToCart_post;
+int HP_clif_pGetItemFromCart_pre;
+int HP_clif_pGetItemFromCart_post;
+int HP_clif_pRemoveOption_pre;
+int HP_clif_pRemoveOption_post;
+int HP_clif_pChangeCart_pre;
+int HP_clif_pChangeCart_post;
+int HP_clif_pStatusUp_pre;
+int HP_clif_pStatusUp_post;
+int HP_clif_pSkillUp_pre;
+int HP_clif_pSkillUp_post;
+int HP_clif_pUseSkillToId_pre;
+int HP_clif_pUseSkillToId_post;
+int HP_clif_pUseSkillToId_homun_pre;
+int HP_clif_pUseSkillToId_homun_post;
+int HP_clif_pUseSkillToId_mercenary_pre;
+int HP_clif_pUseSkillToId_mercenary_post;
+int HP_clif_pUseSkillToPos_pre;
+int HP_clif_pUseSkillToPos_post;
+int HP_clif_pUseSkillToPosSub_pre;
+int HP_clif_pUseSkillToPosSub_post;
+int HP_clif_pUseSkillToPos_homun_pre;
+int HP_clif_pUseSkillToPos_homun_post;
+int HP_clif_pUseSkillToPos_mercenary_pre;
+int HP_clif_pUseSkillToPos_mercenary_post;
+int HP_clif_pUseSkillToPosMoreInfo_pre;
+int HP_clif_pUseSkillToPosMoreInfo_post;
+int HP_clif_pUseSkillMap_pre;
+int HP_clif_pUseSkillMap_post;
+int HP_clif_pRequestMemo_pre;
+int HP_clif_pRequestMemo_post;
+int HP_clif_pProduceMix_pre;
+int HP_clif_pProduceMix_post;
+int HP_clif_pCooking_pre;
+int HP_clif_pCooking_post;
+int HP_clif_pRepairItem_pre;
+int HP_clif_pRepairItem_post;
+int HP_clif_pWeaponRefine_pre;
+int HP_clif_pWeaponRefine_post;
+int HP_clif_pNpcSelectMenu_pre;
+int HP_clif_pNpcSelectMenu_post;
+int HP_clif_pNpcNextClicked_pre;
+int HP_clif_pNpcNextClicked_post;
+int HP_clif_pNpcAmountInput_pre;
+int HP_clif_pNpcAmountInput_post;
+int HP_clif_pNpcStringInput_pre;
+int HP_clif_pNpcStringInput_post;
+int HP_clif_pNpcCloseClicked_pre;
+int HP_clif_pNpcCloseClicked_post;
+int HP_clif_pItemIdentify_pre;
+int HP_clif_pItemIdentify_post;
+int HP_clif_pSelectArrow_pre;
+int HP_clif_pSelectArrow_post;
+int HP_clif_pAutoSpell_pre;
+int HP_clif_pAutoSpell_post;
+int HP_clif_pUseCard_pre;
+int HP_clif_pUseCard_post;
+int HP_clif_pInsertCard_pre;
+int HP_clif_pInsertCard_post;
+int HP_clif_pSolveCharName_pre;
+int HP_clif_pSolveCharName_post;
+int HP_clif_pResetChar_pre;
+int HP_clif_pResetChar_post;
+int HP_clif_pLocalBroadcast_pre;
+int HP_clif_pLocalBroadcast_post;
+int HP_clif_pMoveToKafra_pre;
+int HP_clif_pMoveToKafra_post;
+int HP_clif_pMoveFromKafra_pre;
+int HP_clif_pMoveFromKafra_post;
+int HP_clif_pMoveToKafraFromCart_pre;
+int HP_clif_pMoveToKafraFromCart_post;
+int HP_clif_pMoveFromKafraToCart_pre;
+int HP_clif_pMoveFromKafraToCart_post;
+int HP_clif_pCloseKafra_pre;
+int HP_clif_pCloseKafra_post;
+int HP_clif_pStoragePassword_pre;
+int HP_clif_pStoragePassword_post;
+int HP_clif_pCreateParty_pre;
+int HP_clif_pCreateParty_post;
+int HP_clif_pCreateParty2_pre;
+int HP_clif_pCreateParty2_post;
+int HP_clif_pPartyInvite_pre;
+int HP_clif_pPartyInvite_post;
+int HP_clif_pPartyInvite2_pre;
+int HP_clif_pPartyInvite2_post;
+int HP_clif_pReplyPartyInvite_pre;
+int HP_clif_pReplyPartyInvite_post;
+int HP_clif_pReplyPartyInvite2_pre;
+int HP_clif_pReplyPartyInvite2_post;
+int HP_clif_pLeaveParty_pre;
+int HP_clif_pLeaveParty_post;
+int HP_clif_pRemovePartyMember_pre;
+int HP_clif_pRemovePartyMember_post;
+int HP_clif_pPartyChangeOption_pre;
+int HP_clif_pPartyChangeOption_post;
+int HP_clif_pPartyMessage_pre;
+int HP_clif_pPartyMessage_post;
+int HP_clif_pPartyChangeLeader_pre;
+int HP_clif_pPartyChangeLeader_post;
+int HP_clif_pPartyBookingRegisterReq_pre;
+int HP_clif_pPartyBookingRegisterReq_post;
+int HP_clif_pPartyBookingSearchReq_pre;
+int HP_clif_pPartyBookingSearchReq_post;
+int HP_clif_pPartyBookingDeleteReq_pre;
+int HP_clif_pPartyBookingDeleteReq_post;
+int HP_clif_pPartyBookingUpdateReq_pre;
+int HP_clif_pPartyBookingUpdateReq_post;
+int HP_clif_pCloseVending_pre;
+int HP_clif_pCloseVending_post;
+int HP_clif_pVendingListReq_pre;
+int HP_clif_pVendingListReq_post;
+int HP_clif_pPurchaseReq_pre;
+int HP_clif_pPurchaseReq_post;
+int HP_clif_pPurchaseReq2_pre;
+int HP_clif_pPurchaseReq2_post;
+int HP_clif_pOpenVending_pre;
+int HP_clif_pOpenVending_post;
+int HP_clif_pCreateGuild_pre;
+int HP_clif_pCreateGuild_post;
+int HP_clif_pGuildCheckMaster_pre;
+int HP_clif_pGuildCheckMaster_post;
+int HP_clif_pGuildRequestInfo_pre;
+int HP_clif_pGuildRequestInfo_post;
+int HP_clif_pGuildChangePositionInfo_pre;
+int HP_clif_pGuildChangePositionInfo_post;
+int HP_clif_pGuildChangeMemberPosition_pre;
+int HP_clif_pGuildChangeMemberPosition_post;
+int HP_clif_pGuildRequestEmblem_pre;
+int HP_clif_pGuildRequestEmblem_post;
+int HP_clif_pGuildChangeEmblem_pre;
+int HP_clif_pGuildChangeEmblem_post;
+int HP_clif_pGuildChangeNotice_pre;
+int HP_clif_pGuildChangeNotice_post;
+int HP_clif_pGuildInvite_pre;
+int HP_clif_pGuildInvite_post;
+int HP_clif_pGuildReplyInvite_pre;
+int HP_clif_pGuildReplyInvite_post;
+int HP_clif_pGuildLeave_pre;
+int HP_clif_pGuildLeave_post;
+int HP_clif_pGuildExpulsion_pre;
+int HP_clif_pGuildExpulsion_post;
+int HP_clif_pGuildMessage_pre;
+int HP_clif_pGuildMessage_post;
+int HP_clif_pGuildRequestAlliance_pre;
+int HP_clif_pGuildRequestAlliance_post;
+int HP_clif_pGuildReplyAlliance_pre;
+int HP_clif_pGuildReplyAlliance_post;
+int HP_clif_pGuildDelAlliance_pre;
+int HP_clif_pGuildDelAlliance_post;
+int HP_clif_pGuildOpposition_pre;
+int HP_clif_pGuildOpposition_post;
+int HP_clif_pGuildBreak_pre;
+int HP_clif_pGuildBreak_post;
+int HP_clif_pPetMenu_pre;
+int HP_clif_pPetMenu_post;
+int HP_clif_pCatchPet_pre;
+int HP_clif_pCatchPet_post;
+int HP_clif_pSelectEgg_pre;
+int HP_clif_pSelectEgg_post;
+int HP_clif_pSendEmotion_pre;
+int HP_clif_pSendEmotion_post;
+int HP_clif_pChangePetName_pre;
+int HP_clif_pChangePetName_post;
+int HP_clif_pGMKick_pre;
+int HP_clif_pGMKick_post;
+int HP_clif_pGMKickAll_pre;
+int HP_clif_pGMKickAll_post;
+int HP_clif_pGMShift_pre;
+int HP_clif_pGMShift_post;
+int HP_clif_pGMRemove2_pre;
+int HP_clif_pGMRemove2_post;
+int HP_clif_pGMRecall_pre;
+int HP_clif_pGMRecall_post;
+int HP_clif_pGMRecall2_pre;
+int HP_clif_pGMRecall2_post;
+int HP_clif_pGM_Monster_Item_pre;
+int HP_clif_pGM_Monster_Item_post;
+int HP_clif_pGMHide_pre;
+int HP_clif_pGMHide_post;
+int HP_clif_pGMReqNoChat_pre;
+int HP_clif_pGMReqNoChat_post;
+int HP_clif_pGMRc_pre;
+int HP_clif_pGMRc_post;
+int HP_clif_pGMReqAccountName_pre;
+int HP_clif_pGMReqAccountName_post;
+int HP_clif_pGMChangeMapType_pre;
+int HP_clif_pGMChangeMapType_post;
+int HP_clif_pPMIgnore_pre;
+int HP_clif_pPMIgnore_post;
+int HP_clif_pPMIgnoreAll_pre;
+int HP_clif_pPMIgnoreAll_post;
+int HP_clif_pPMIgnoreList_pre;
+int HP_clif_pPMIgnoreList_post;
+int HP_clif_pNoviceDoriDori_pre;
+int HP_clif_pNoviceDoriDori_post;
+int HP_clif_pNoviceExplosionSpirits_pre;
+int HP_clif_pNoviceExplosionSpirits_post;
+int HP_clif_pFriendsListAdd_pre;
+int HP_clif_pFriendsListAdd_post;
+int HP_clif_pFriendsListReply_pre;
+int HP_clif_pFriendsListReply_post;
+int HP_clif_pFriendsListRemove_pre;
+int HP_clif_pFriendsListRemove_post;
+int HP_clif_pPVPInfo_pre;
+int HP_clif_pPVPInfo_post;
+int HP_clif_pBlacksmith_pre;
+int HP_clif_pBlacksmith_post;
+int HP_clif_pAlchemist_pre;
+int HP_clif_pAlchemist_post;
+int HP_clif_pTaekwon_pre;
+int HP_clif_pTaekwon_post;
+int HP_clif_pRankingPk_pre;
+int HP_clif_pRankingPk_post;
+int HP_clif_pFeelSaveOk_pre;
+int HP_clif_pFeelSaveOk_post;
+int HP_clif_pChangeHomunculusName_pre;
+int HP_clif_pChangeHomunculusName_post;
+int HP_clif_pHomMoveToMaster_pre;
+int HP_clif_pHomMoveToMaster_post;
+int HP_clif_pHomMoveTo_pre;
+int HP_clif_pHomMoveTo_post;
+int HP_clif_pHomAttack_pre;
+int HP_clif_pHomAttack_post;
+int HP_clif_pHomMenu_pre;
+int HP_clif_pHomMenu_post;
+int HP_clif_pAutoRevive_pre;
+int HP_clif_pAutoRevive_post;
+int HP_clif_pCheck_pre;
+int HP_clif_pCheck_post;
+int HP_clif_pMail_refreshinbox_pre;
+int HP_clif_pMail_refreshinbox_post;
+int HP_clif_pMail_read_pre;
+int HP_clif_pMail_read_post;
+int HP_clif_pMail_getattach_pre;
+int HP_clif_pMail_getattach_post;
+int HP_clif_pMail_delete_pre;
+int HP_clif_pMail_delete_post;
+int HP_clif_pMail_return_pre;
+int HP_clif_pMail_return_post;
+int HP_clif_pMail_setattach_pre;
+int HP_clif_pMail_setattach_post;
+int HP_clif_pMail_winopen_pre;
+int HP_clif_pMail_winopen_post;
+int HP_clif_pMail_send_pre;
+int HP_clif_pMail_send_post;
+int HP_clif_pAuction_cancelreg_pre;
+int HP_clif_pAuction_cancelreg_post;
+int HP_clif_pAuction_setitem_pre;
+int HP_clif_pAuction_setitem_post;
+int HP_clif_pAuction_register_pre;
+int HP_clif_pAuction_register_post;
+int HP_clif_pAuction_cancel_pre;
+int HP_clif_pAuction_cancel_post;
+int HP_clif_pAuction_close_pre;
+int HP_clif_pAuction_close_post;
+int HP_clif_pAuction_bid_pre;
+int HP_clif_pAuction_bid_post;
+int HP_clif_pAuction_search_pre;
+int HP_clif_pAuction_search_post;
+int HP_clif_pAuction_buysell_pre;
+int HP_clif_pAuction_buysell_post;
+int HP_clif_pcashshop_buy_pre;
+int HP_clif_pcashshop_buy_post;
+int HP_clif_pAdopt_request_pre;
+int HP_clif_pAdopt_request_post;
+int HP_clif_pAdopt_reply_pre;
+int HP_clif_pAdopt_reply_post;
+int HP_clif_pViewPlayerEquip_pre;
+int HP_clif_pViewPlayerEquip_post;
+int HP_clif_pEquipTick_pre;
+int HP_clif_pEquipTick_post;
+int HP_clif_pquestStateAck_pre;
+int HP_clif_pquestStateAck_post;
+int HP_clif_pmercenary_action_pre;
+int HP_clif_pmercenary_action_post;
+int HP_clif_pBattleChat_pre;
+int HP_clif_pBattleChat_post;
+int HP_clif_pLessEffect_pre;
+int HP_clif_pLessEffect_post;
+int HP_clif_pItemListWindowSelected_pre;
+int HP_clif_pItemListWindowSelected_post;
+int HP_clif_pReqOpenBuyingStore_pre;
+int HP_clif_pReqOpenBuyingStore_post;
+int HP_clif_pReqCloseBuyingStore_pre;
+int HP_clif_pReqCloseBuyingStore_post;
+int HP_clif_pReqClickBuyingStore_pre;
+int HP_clif_pReqClickBuyingStore_post;
+int HP_clif_pReqTradeBuyingStore_pre;
+int HP_clif_pReqTradeBuyingStore_post;
+int HP_clif_pSearchStoreInfo_pre;
+int HP_clif_pSearchStoreInfo_post;
+int HP_clif_pSearchStoreInfoNextPage_pre;
+int HP_clif_pSearchStoreInfoNextPage_post;
+int HP_clif_pCloseSearchStoreInfo_pre;
+int HP_clif_pCloseSearchStoreInfo_post;
+int HP_clif_pSearchStoreInfoListItemClick_pre;
+int HP_clif_pSearchStoreInfoListItemClick_post;
+int HP_clif_pDebug_pre;
+int HP_clif_pDebug_post;
+int HP_clif_pSkillSelectMenu_pre;
+int HP_clif_pSkillSelectMenu_post;
+int HP_clif_pMoveItem_pre;
+int HP_clif_pMoveItem_post;
+int HP_clif_pDull_pre;
+int HP_clif_pDull_post;
+int HP_clif_pBGQueueRegister_pre;
+int HP_clif_pBGQueueRegister_post;
+int HP_clif_pBGQueueCheckState_pre;
+int HP_clif_pBGQueueCheckState_post;
+int HP_clif_pBGQueueRevokeReq_pre;
+int HP_clif_pBGQueueRevokeReq_post;
+int HP_clif_pBGQueueBattleBeginAck_pre;
+int HP_clif_pBGQueueBattleBeginAck_post;
+int HP_clif_pCashShopOpen_pre;
+int HP_clif_pCashShopOpen_post;
+int HP_clif_pCashShopClose_pre;
+int HP_clif_pCashShopClose_post;
+int HP_clif_pCashShopReqTab_pre;
+int HP_clif_pCashShopReqTab_post;
+int HP_clif_pCashShopSchedule_pre;
+int HP_clif_pCashShopSchedule_post;
+int HP_clif_pCashShopBuy_pre;
+int HP_clif_pCashShopBuy_post;
+int HP_clif_pPartyTick_pre;
+int HP_clif_pPartyTick_post;
+int HP_clif_pGuildInvite2_pre;
+int HP_clif_pGuildInvite2_post;
+int HP_clif_pPartyBookingAddFilter_pre;
+int HP_clif_pPartyBookingAddFilter_post;
+int HP_clif_pPartyBookingSubFilter_pre;
+int HP_clif_pPartyBookingSubFilter_post;
+int HP_clif_pPartyBookingReqVolunteer_pre;
+int HP_clif_pPartyBookingReqVolunteer_post;
+int HP_clif_pPartyBookingRefuseVolunteer_pre;
+int HP_clif_pPartyBookingRefuseVolunteer_post;
+int HP_clif_pPartyBookingCancelVolunteer_pre;
+int HP_clif_pPartyBookingCancelVolunteer_post;
+int HP_duel_create_pre;
+int HP_duel_create_post;
+int HP_duel_invite_pre;
+int HP_duel_invite_post;
+int HP_duel_accept_pre;
+int HP_duel_accept_post;
+int HP_duel_reject_pre;
+int HP_duel_reject_post;
+int HP_duel_leave_pre;
+int HP_duel_leave_post;
+int HP_duel_showinfo_pre;
+int HP_duel_showinfo_post;
+int HP_duel_checktime_pre;
+int HP_duel_checktime_post;
+int HP_duel_init_pre;
+int HP_duel_init_post;
+int HP_duel_final_pre;
+int HP_duel_final_post;
+int HP_elemental_init_pre;
+int HP_elemental_init_post;
+int HP_elemental_final_pre;
+int HP_elemental_final_post;
+int HP_elemental_class_pre;
+int HP_elemental_class_post;
+int HP_elemental_get_viewdata_pre;
+int HP_elemental_get_viewdata_post;
+int HP_elemental_create_pre;
+int HP_elemental_create_post;
+int HP_elemental_data_received_pre;
+int HP_elemental_data_received_post;
+int HP_elemental_save_pre;
+int HP_elemental_save_post;
+int HP_elemental_change_mode_ack_pre;
+int HP_elemental_change_mode_ack_post;
+int HP_elemental_change_mode_pre;
+int HP_elemental_change_mode_post;
+int HP_elemental_heal_pre;
+int HP_elemental_heal_post;
+int HP_elemental_dead_pre;
+int HP_elemental_dead_post;
+int HP_elemental_delete_pre;
+int HP_elemental_delete_post;
+int HP_elemental_summon_stop_pre;
+int HP_elemental_summon_stop_post;
+int HP_elemental_get_lifetime_pre;
+int HP_elemental_get_lifetime_post;
+int HP_elemental_unlocktarget_pre;
+int HP_elemental_unlocktarget_post;
+int HP_elemental_skillnotok_pre;
+int HP_elemental_skillnotok_post;
+int HP_elemental_set_target_pre;
+int HP_elemental_set_target_post;
+int HP_elemental_clean_single_effect_pre;
+int HP_elemental_clean_single_effect_post;
+int HP_elemental_clean_effect_pre;
+int HP_elemental_clean_effect_post;
+int HP_elemental_action_pre;
+int HP_elemental_action_post;
+int HP_elemental_skill_get_requirements_pre;
+int HP_elemental_skill_get_requirements_post;
+int HP_elemental_read_skilldb_pre;
+int HP_elemental_read_skilldb_post;
+int HP_elemental_reload_db_pre;
+int HP_elemental_reload_db_post;
+int HP_elemental_reload_skilldb_pre;
+int HP_elemental_reload_skilldb_post;
+int HP_elemental_search_index_pre;
+int HP_elemental_search_index_post;
+int HP_elemental_summon_init_pre;
+int HP_elemental_summon_init_post;
+int HP_elemental_summon_end_timer_pre;
+int HP_elemental_summon_end_timer_post;
+int HP_elemental_ai_sub_timer_activesearch_pre;
+int HP_elemental_ai_sub_timer_activesearch_post;
+int HP_elemental_ai_sub_timer_pre;
+int HP_elemental_ai_sub_timer_post;
+int HP_elemental_ai_sub_foreachclient_pre;
+int HP_elemental_ai_sub_foreachclient_post;
+int HP_elemental_ai_timer_pre;
+int HP_elemental_ai_timer_post;
+int HP_elemental_read_db_pre;
+int HP_elemental_read_db_post;
+int HP_guild_init_pre;
+int HP_guild_init_post;
+int HP_guild_final_pre;
+int HP_guild_final_post;
+int HP_guild_skill_get_max_pre;
+int HP_guild_skill_get_max_post;
+int HP_guild_checkskill_pre;
+int HP_guild_checkskill_post;
+int HP_guild_check_skill_require_pre;
+int HP_guild_check_skill_require_post;
+int HP_guild_checkcastles_pre;
+int HP_guild_checkcastles_post;
+int HP_guild_isallied_pre;
+int HP_guild_isallied_post;
+int HP_guild_search_pre;
+int HP_guild_search_post;
+int HP_guild_searchname_pre;
+int HP_guild_searchname_post;
+int HP_guild_castle_search_pre;
+int HP_guild_castle_search_post;
+int HP_guild_mapname2gc_pre;
+int HP_guild_mapname2gc_post;
+int HP_guild_mapindex2gc_pre;
+int HP_guild_mapindex2gc_post;
+int HP_guild_getavailablesd_pre;
+int HP_guild_getavailablesd_post;
+int HP_guild_getindex_pre;
+int HP_guild_getindex_post;
+int HP_guild_getposition_pre;
+int HP_guild_getposition_post;
+int HP_guild_payexp_pre;
+int HP_guild_payexp_post;
+int HP_guild_getexp_pre;
+int HP_guild_getexp_post;
+int HP_guild_create_pre;
+int HP_guild_create_post;
+int HP_guild_created_pre;
+int HP_guild_created_post;
+int HP_guild_request_info_pre;
+int HP_guild_request_info_post;
+int HP_guild_recv_noinfo_pre;
+int HP_guild_recv_noinfo_post;
+int HP_guild_recv_info_pre;
+int HP_guild_recv_info_post;
+int HP_guild_npc_request_info_pre;
+int HP_guild_npc_request_info_post;
+int HP_guild_invite_pre;
+int HP_guild_invite_post;
+int HP_guild_reply_invite_pre;
+int HP_guild_reply_invite_post;
+int HP_guild_member_joined_pre;
+int HP_guild_member_joined_post;
+int HP_guild_member_added_pre;
+int HP_guild_member_added_post;
+int HP_guild_leave_pre;
+int HP_guild_leave_post;
+int HP_guild_member_withdraw_pre;
+int HP_guild_member_withdraw_post;
+int HP_guild_expulsion_pre;
+int HP_guild_expulsion_post;
+int HP_guild_skillup_pre;
+int HP_guild_skillup_post;
+int HP_guild_block_skill_pre;
+int HP_guild_block_skill_post;
+int HP_guild_reqalliance_pre;
+int HP_guild_reqalliance_post;
+int HP_guild_reply_reqalliance_pre;
+int HP_guild_reply_reqalliance_post;
+int HP_guild_allianceack_pre;
+int HP_guild_allianceack_post;
+int HP_guild_delalliance_pre;
+int HP_guild_delalliance_post;
+int HP_guild_opposition_pre;
+int HP_guild_opposition_post;
+int HP_guild_check_alliance_pre;
+int HP_guild_check_alliance_post;
+int HP_guild_send_memberinfoshort_pre;
+int HP_guild_send_memberinfoshort_post;
+int HP_guild_recv_memberinfoshort_pre;
+int HP_guild_recv_memberinfoshort_post;
+int HP_guild_change_memberposition_pre;
+int HP_guild_change_memberposition_post;
+int HP_guild_memberposition_changed_pre;
+int HP_guild_memberposition_changed_post;
+int HP_guild_change_position_pre;
+int HP_guild_change_position_post;
+int HP_guild_position_changed_pre;
+int HP_guild_position_changed_post;
+int HP_guild_change_notice_pre;
+int HP_guild_change_notice_post;
+int HP_guild_notice_changed_pre;
+int HP_guild_notice_changed_post;
+int HP_guild_change_emblem_pre;
+int HP_guild_change_emblem_post;
+int HP_guild_emblem_changed_pre;
+int HP_guild_emblem_changed_post;
+int HP_guild_send_message_pre;
+int HP_guild_send_message_post;
+int HP_guild_recv_message_pre;
+int HP_guild_recv_message_post;
+int HP_guild_send_dot_remove_pre;
+int HP_guild_send_dot_remove_post;
+int HP_guild_skillupack_pre;
+int HP_guild_skillupack_post;
+int HP_guild_dobreak_pre;
+int HP_guild_dobreak_post;
+int HP_guild_broken_pre;
+int HP_guild_broken_post;
+int HP_guild_gm_change_pre;
+int HP_guild_gm_change_post;
+int HP_guild_gm_changed_pre;
+int HP_guild_gm_changed_post;
+int HP_guild_castle_map_init_pre;
+int HP_guild_castle_map_init_post;
+int HP_guild_castledatasave_pre;
+int HP_guild_castledatasave_post;
+int HP_guild_castledataloadack_pre;
+int HP_guild_castledataloadack_post;
+int HP_guild_castle_reconnect_pre;
+int HP_guild_castle_reconnect_post;
+int HP_guild_agit_start_pre;
+int HP_guild_agit_start_post;
+int HP_guild_agit_end_pre;
+int HP_guild_agit_end_post;
+int HP_guild_agit2_start_pre;
+int HP_guild_agit2_start_post;
+int HP_guild_agit2_end_pre;
+int HP_guild_agit2_end_post;
+int HP_guild_flag_add_pre;
+int HP_guild_flag_add_post;
+int HP_guild_flag_remove_pre;
+int HP_guild_flag_remove_post;
+int HP_guild_flags_clear_pre;
+int HP_guild_flags_clear_post;
+int HP_guild_aura_refresh_pre;
+int HP_guild_aura_refresh_post;
+int HP_guild_payexp_timer_pre;
+int HP_guild_payexp_timer_post;
+int HP_guild_sd_check_pre;
+int HP_guild_sd_check_post;
+int HP_guild_read_guildskill_tree_db_pre;
+int HP_guild_read_guildskill_tree_db_post;
+int HP_guild_read_castledb_pre;
+int HP_guild_read_castledb_post;
+int HP_guild_payexp_timer_sub_pre;
+int HP_guild_payexp_timer_sub_post;
+int HP_guild_send_xy_timer_sub_pre;
+int HP_guild_send_xy_timer_sub_post;
+int HP_guild_send_xy_timer_pre;
+int HP_guild_send_xy_timer_post;
+int HP_guild_create_expcache_pre;
+int HP_guild_create_expcache_post;
+int HP_guild_eventlist_db_final_pre;
+int HP_guild_eventlist_db_final_post;
+int HP_guild_expcache_db_final_pre;
+int HP_guild_expcache_db_final_post;
+int HP_guild_castle_db_final_pre;
+int HP_guild_castle_db_final_post;
+int HP_guild_broken_sub_pre;
+int HP_guild_broken_sub_post;
+int HP_guild_castle_broken_sub_pre;
+int HP_guild_castle_broken_sub_post;
+int HP_guild_makemember_pre;
+int HP_guild_makemember_post;
+int HP_guild_check_member_pre;
+int HP_guild_check_member_post;
+int HP_guild_get_alliance_count_pre;
+int HP_guild_get_alliance_count_post;
+int HP_guild_castle_reconnect_sub_pre;
+int HP_guild_castle_reconnect_sub_post;
+int HP_gstorage_id2storage_pre;
+int HP_gstorage_id2storage_post;
+int HP_gstorage_id2storage2_pre;
+int HP_gstorage_id2storage2_post;
+int HP_gstorage_init_pre;
+int HP_gstorage_init_post;
+int HP_gstorage_final_pre;
+int HP_gstorage_final_post;
+int HP_gstorage_delete_pre;
+int HP_gstorage_delete_post;
+int HP_gstorage_open_pre;
+int HP_gstorage_open_post;
+int HP_gstorage_additem_pre;
+int HP_gstorage_additem_post;
+int HP_gstorage_delitem_pre;
+int HP_gstorage_delitem_post;
+int HP_gstorage_add_pre;
+int HP_gstorage_add_post;
+int HP_gstorage_get_pre;
+int HP_gstorage_get_post;
+int HP_gstorage_addfromcart_pre;
+int HP_gstorage_addfromcart_post;
+int HP_gstorage_gettocart_pre;
+int HP_gstorage_gettocart_post;
+int HP_gstorage_close_pre;
+int HP_gstorage_close_post;
+int HP_gstorage_pc_quit_pre;
+int HP_gstorage_pc_quit_post;
+int HP_gstorage_save_pre;
+int HP_gstorage_save_post;
+int HP_gstorage_saved_pre;
+int HP_gstorage_saved_post;
+int HP_gstorage_create_pre;
+int HP_gstorage_create_post;
+int HP_homun_init_pre;
+int HP_homun_init_post;
+int HP_homun_final_pre;
+int HP_homun_final_post;
+int HP_homun_reload_pre;
+int HP_homun_reload_post;
+int HP_homun_reload_skill_pre;
+int HP_homun_reload_skill_post;
+int HP_homun_get_viewdata_pre;
+int HP_homun_get_viewdata_post;
+int HP_homun_class2type_pre;
+int HP_homun_class2type_post;
+int HP_homun_damaged_pre;
+int HP_homun_damaged_post;
+int HP_homun_dead_pre;
+int HP_homun_dead_post;
+int HP_homun_vaporize_pre;
+int HP_homun_vaporize_post;
+int HP_homun_delete_pre;
+int HP_homun_delete_post;
+int HP_homun_checkskill_pre;
+int HP_homun_checkskill_post;
+int HP_homun_calc_skilltree_pre;
+int HP_homun_calc_skilltree_post;
+int HP_homun_skill_tree_get_max_pre;
+int HP_homun_skill_tree_get_max_post;
+int HP_homun_skillup_pre;
+int HP_homun_skillup_post;
+int HP_homun_levelup_pre;
+int HP_homun_levelup_post;
+int HP_homun_change_class_pre;
+int HP_homun_change_class_post;
+int HP_homun_evolve_pre;
+int HP_homun_evolve_post;
+int HP_homun_mutate_pre;
+int HP_homun_mutate_post;
+int HP_homun_gainexp_pre;
+int HP_homun_gainexp_post;
+int HP_homun_add_intimacy_pre;
+int HP_homun_add_intimacy_post;
+int HP_homun_consume_intimacy_pre;
+int HP_homun_consume_intimacy_post;
+int HP_homun_healed_pre;
+int HP_homun_healed_post;
+int HP_homun_save_pre;
+int HP_homun_save_post;
+int HP_homun_menu_pre;
+int HP_homun_menu_post;
+int HP_homun_feed_pre;
+int HP_homun_feed_post;
+int HP_homun_hunger_timer_pre;
+int HP_homun_hunger_timer_post;
+int HP_homun_hunger_timer_delete_pre;
+int HP_homun_hunger_timer_delete_post;
+int HP_homun_change_name_pre;
+int HP_homun_change_name_post;
+int HP_homun_change_name_ack_pre;
+int HP_homun_change_name_ack_post;
+int HP_homun_db_search_pre;
+int HP_homun_db_search_post;
+int HP_homun_create_pre;
+int HP_homun_create_post;
+int HP_homun_init_timers_pre;
+int HP_homun_init_timers_post;
+int HP_homun_call_pre;
+int HP_homun_call_post;
+int HP_homun_recv_data_pre;
+int HP_homun_recv_data_post;
+int HP_homun_creation_request_pre;
+int HP_homun_creation_request_post;
+int HP_homun_ressurect_pre;
+int HP_homun_ressurect_post;
+int HP_homun_revive_pre;
+int HP_homun_revive_post;
+int HP_homun_stat_reset_pre;
+int HP_homun_stat_reset_post;
+int HP_homun_shuffle_pre;
+int HP_homun_shuffle_post;
+int HP_homun_read_db_sub_pre;
+int HP_homun_read_db_sub_post;
+int HP_homun_read_db_pre;
+int HP_homun_read_db_post;
+int HP_homun_read_skill_db_sub_pre;
+int HP_homun_read_skill_db_sub_post;
+int HP_homun_skill_db_read_pre;
+int HP_homun_skill_db_read_post;
+int HP_homun_exp_db_read_pre;
+int HP_homun_exp_db_read_post;
+int HP_homun_addspiritball_pre;
+int HP_homun_addspiritball_post;
+int HP_homun_delspiritball_pre;
+int HP_homun_delspiritball_post;
+int HP_instance_init_pre;
+int HP_instance_init_post;
+int HP_instance_final_pre;
+int HP_instance_final_post;
+int HP_instance_create_pre;
+int HP_instance_create_post;
+int HP_instance_add_map_pre;
+int HP_instance_add_map_post;
+int HP_instance_del_map_pre;
+int HP_instance_del_map_post;
+int HP_instance_map2imap_pre;
+int HP_instance_map2imap_post;
+int HP_instance_mapid2imapid_pre;
+int HP_instance_mapid2imapid_post;
+int HP_instance_destroy_pre;
+int HP_instance_destroy_post;
+int HP_instance_start_pre;
+int HP_instance_start_post;
+int HP_instance_check_idle_pre;
+int HP_instance_check_idle_post;
+int HP_instance_check_kick_pre;
+int HP_instance_check_kick_post;
+int HP_instance_set_timeout_pre;
+int HP_instance_set_timeout_post;
+int HP_instance_valid_pre;
+int HP_instance_valid_post;
+int HP_instance_destroy_timer_pre;
+int HP_instance_destroy_timer_post;
+int HP_intif_parse_pre;
+int HP_intif_parse_post;
+int HP_intif_create_pet_pre;
+int HP_intif_create_pet_post;
+int HP_intif_broadcast_pre;
+int HP_intif_broadcast_post;
+int HP_intif_broadcast2_pre;
+int HP_intif_broadcast2_post;
+int HP_intif_main_message_pre;
+int HP_intif_main_message_post;
+int HP_intif_wis_message_pre;
+int HP_intif_wis_message_post;
+int HP_intif_wis_message_to_gm_pre;
+int HP_intif_wis_message_to_gm_post;
+int HP_intif_saveregistry_pre;
+int HP_intif_saveregistry_post;
+int HP_intif_request_registry_pre;
+int HP_intif_request_registry_post;
+int HP_intif_request_guild_storage_pre;
+int HP_intif_request_guild_storage_post;
+int HP_intif_send_guild_storage_pre;
+int HP_intif_send_guild_storage_post;
+int HP_intif_create_party_pre;
+int HP_intif_create_party_post;
+int HP_intif_request_partyinfo_pre;
+int HP_intif_request_partyinfo_post;
+int HP_intif_party_addmember_pre;
+int HP_intif_party_addmember_post;
+int HP_intif_party_changeoption_pre;
+int HP_intif_party_changeoption_post;
+int HP_intif_party_leave_pre;
+int HP_intif_party_leave_post;
+int HP_intif_party_changemap_pre;
+int HP_intif_party_changemap_post;
+int HP_intif_break_party_pre;
+int HP_intif_break_party_post;
+int HP_intif_party_message_pre;
+int HP_intif_party_message_post;
+int HP_intif_party_leaderchange_pre;
+int HP_intif_party_leaderchange_post;
+int HP_intif_guild_create_pre;
+int HP_intif_guild_create_post;
+int HP_intif_guild_request_info_pre;
+int HP_intif_guild_request_info_post;
+int HP_intif_guild_addmember_pre;
+int HP_intif_guild_addmember_post;
+int HP_intif_guild_leave_pre;
+int HP_intif_guild_leave_post;
+int HP_intif_guild_memberinfoshort_pre;
+int HP_intif_guild_memberinfoshort_post;
+int HP_intif_guild_break_pre;
+int HP_intif_guild_break_post;
+int HP_intif_guild_message_pre;
+int HP_intif_guild_message_post;
+int HP_intif_guild_change_gm_pre;
+int HP_intif_guild_change_gm_post;
+int HP_intif_guild_change_basicinfo_pre;
+int HP_intif_guild_change_basicinfo_post;
+int HP_intif_guild_change_memberinfo_pre;
+int HP_intif_guild_change_memberinfo_post;
+int HP_intif_guild_position_pre;
+int HP_intif_guild_position_post;
+int HP_intif_guild_skillup_pre;
+int HP_intif_guild_skillup_post;
+int HP_intif_guild_alliance_pre;
+int HP_intif_guild_alliance_post;
+int HP_intif_guild_notice_pre;
+int HP_intif_guild_notice_post;
+int HP_intif_guild_emblem_pre;
+int HP_intif_guild_emblem_post;
+int HP_intif_guild_castle_dataload_pre;
+int HP_intif_guild_castle_dataload_post;
+int HP_intif_guild_castle_datasave_pre;
+int HP_intif_guild_castle_datasave_post;
+int HP_intif_request_petdata_pre;
+int HP_intif_request_petdata_post;
+int HP_intif_save_petdata_pre;
+int HP_intif_save_petdata_post;
+int HP_intif_delete_petdata_pre;
+int HP_intif_delete_petdata_post;
+int HP_intif_rename_pre;
+int HP_intif_rename_post;
+int HP_intif_homunculus_create_pre;
+int HP_intif_homunculus_create_post;
+int HP_intif_homunculus_requestload_pre;
+int HP_intif_homunculus_requestload_post;
+int HP_intif_homunculus_requestsave_pre;
+int HP_intif_homunculus_requestsave_post;
+int HP_intif_homunculus_requestdelete_pre;
+int HP_intif_homunculus_requestdelete_post;
+int HP_intif_request_questlog_pre;
+int HP_intif_request_questlog_post;
+int HP_intif_quest_save_pre;
+int HP_intif_quest_save_post;
+int HP_intif_mercenary_create_pre;
+int HP_intif_mercenary_create_post;
+int HP_intif_mercenary_request_pre;
+int HP_intif_mercenary_request_post;
+int HP_intif_mercenary_delete_pre;
+int HP_intif_mercenary_delete_post;
+int HP_intif_mercenary_save_pre;
+int HP_intif_mercenary_save_post;
+int HP_intif_Mail_requestinbox_pre;
+int HP_intif_Mail_requestinbox_post;
+int HP_intif_Mail_read_pre;
+int HP_intif_Mail_read_post;
+int HP_intif_Mail_getattach_pre;
+int HP_intif_Mail_getattach_post;
+int HP_intif_Mail_delete_pre;
+int HP_intif_Mail_delete_post;
+int HP_intif_Mail_return_pre;
+int HP_intif_Mail_return_post;
+int HP_intif_Mail_send_pre;
+int HP_intif_Mail_send_post;
+int HP_intif_Auction_requestlist_pre;
+int HP_intif_Auction_requestlist_post;
+int HP_intif_Auction_register_pre;
+int HP_intif_Auction_register_post;
+int HP_intif_Auction_cancel_pre;
+int HP_intif_Auction_cancel_post;
+int HP_intif_Auction_close_pre;
+int HP_intif_Auction_close_post;
+int HP_intif_Auction_bid_pre;
+int HP_intif_Auction_bid_post;
+int HP_intif_elemental_create_pre;
+int HP_intif_elemental_create_post;
+int HP_intif_elemental_request_pre;
+int HP_intif_elemental_request_post;
+int HP_intif_elemental_delete_pre;
+int HP_intif_elemental_delete_post;
+int HP_intif_elemental_save_pre;
+int HP_intif_elemental_save_post;
+int HP_intif_request_accinfo_pre;
+int HP_intif_request_accinfo_post;
+int HP_intif_CheckForCharServer_pre;
+int HP_intif_CheckForCharServer_post;
+int HP_intif_pWisMessage_pre;
+int HP_intif_pWisMessage_post;
+int HP_intif_pWisEnd_pre;
+int HP_intif_pWisEnd_post;
+int HP_intif_pWisToGM_sub_pre;
+int HP_intif_pWisToGM_sub_post;
+int HP_intif_pWisToGM_pre;
+int HP_intif_pWisToGM_post;
+int HP_intif_pRegisters_pre;
+int HP_intif_pRegisters_post;
+int HP_intif_pChangeNameOk_pre;
+int HP_intif_pChangeNameOk_post;
+int HP_intif_pMessageToFD_pre;
+int HP_intif_pMessageToFD_post;
+int HP_intif_pLoadGuildStorage_pre;
+int HP_intif_pLoadGuildStorage_post;
+int HP_intif_pSaveGuildStorage_pre;
+int HP_intif_pSaveGuildStorage_post;
+int HP_intif_pPartyCreated_pre;
+int HP_intif_pPartyCreated_post;
+int HP_intif_pPartyInfo_pre;
+int HP_intif_pPartyInfo_post;
+int HP_intif_pPartyMemberAdded_pre;
+int HP_intif_pPartyMemberAdded_post;
+int HP_intif_pPartyOptionChanged_pre;
+int HP_intif_pPartyOptionChanged_post;
+int HP_intif_pPartyMemberWithdraw_pre;
+int HP_intif_pPartyMemberWithdraw_post;
+int HP_intif_pPartyMove_pre;
+int HP_intif_pPartyMove_post;
+int HP_intif_pPartyBroken_pre;
+int HP_intif_pPartyBroken_post;
+int HP_intif_pPartyMessage_pre;
+int HP_intif_pPartyMessage_post;
+int HP_intif_pGuildCreated_pre;
+int HP_intif_pGuildCreated_post;
+int HP_intif_pGuildInfo_pre;
+int HP_intif_pGuildInfo_post;
+int HP_intif_pGuildMemberAdded_pre;
+int HP_intif_pGuildMemberAdded_post;
+int HP_intif_pGuildMemberWithdraw_pre;
+int HP_intif_pGuildMemberWithdraw_post;
+int HP_intif_pGuildMemberInfoShort_pre;
+int HP_intif_pGuildMemberInfoShort_post;
+int HP_intif_pGuildBroken_pre;
+int HP_intif_pGuildBroken_post;
+int HP_intif_pGuildMessage_pre;
+int HP_intif_pGuildMessage_post;
+int HP_intif_pGuildBasicInfoChanged_pre;
+int HP_intif_pGuildBasicInfoChanged_post;
+int HP_intif_pGuildMemberInfoChanged_pre;
+int HP_intif_pGuildMemberInfoChanged_post;
+int HP_intif_pGuildPosition_pre;
+int HP_intif_pGuildPosition_post;
+int HP_intif_pGuildSkillUp_pre;
+int HP_intif_pGuildSkillUp_post;
+int HP_intif_pGuildAlliance_pre;
+int HP_intif_pGuildAlliance_post;
+int HP_intif_pGuildNotice_pre;
+int HP_intif_pGuildNotice_post;
+int HP_intif_pGuildEmblem_pre;
+int HP_intif_pGuildEmblem_post;
+int HP_intif_pGuildCastleDataLoad_pre;
+int HP_intif_pGuildCastleDataLoad_post;
+int HP_intif_pGuildMasterChanged_pre;
+int HP_intif_pGuildMasterChanged_post;
+int HP_intif_pQuestLog_pre;
+int HP_intif_pQuestLog_post;
+int HP_intif_pQuestSave_pre;
+int HP_intif_pQuestSave_post;
+int HP_intif_pMailInboxReceived_pre;
+int HP_intif_pMailInboxReceived_post;
+int HP_intif_pMailNew_pre;
+int HP_intif_pMailNew_post;
+int HP_intif_pMailGetAttach_pre;
+int HP_intif_pMailGetAttach_post;
+int HP_intif_pMailDelete_pre;
+int HP_intif_pMailDelete_post;
+int HP_intif_pMailReturn_pre;
+int HP_intif_pMailReturn_post;
+int HP_intif_pMailSend_pre;
+int HP_intif_pMailSend_post;
+int HP_intif_pAuctionResults_pre;
+int HP_intif_pAuctionResults_post;
+int HP_intif_pAuctionRegister_pre;
+int HP_intif_pAuctionRegister_post;
+int HP_intif_pAuctionCancel_pre;
+int HP_intif_pAuctionCancel_post;
+int HP_intif_pAuctionClose_pre;
+int HP_intif_pAuctionClose_post;
+int HP_intif_pAuctionMessage_pre;
+int HP_intif_pAuctionMessage_post;
+int HP_intif_pAuctionBid_pre;
+int HP_intif_pAuctionBid_post;
+int HP_intif_pMercenaryReceived_pre;
+int HP_intif_pMercenaryReceived_post;
+int HP_intif_pMercenaryDeleted_pre;
+int HP_intif_pMercenaryDeleted_post;
+int HP_intif_pMercenarySaved_pre;
+int HP_intif_pMercenarySaved_post;
+int HP_intif_pElementalReceived_pre;
+int HP_intif_pElementalReceived_post;
+int HP_intif_pElementalDeleted_pre;
+int HP_intif_pElementalDeleted_post;
+int HP_intif_pElementalSaved_pre;
+int HP_intif_pElementalSaved_post;
+int HP_intif_pCreatePet_pre;
+int HP_intif_pCreatePet_post;
+int HP_intif_pRecvPetData_pre;
+int HP_intif_pRecvPetData_post;
+int HP_intif_pSavePetOk_pre;
+int HP_intif_pSavePetOk_post;
+int HP_intif_pDeletePetOk_pre;
+int HP_intif_pDeletePetOk_post;
+int HP_intif_pCreateHomunculus_pre;
+int HP_intif_pCreateHomunculus_post;
+int HP_intif_pRecvHomunculusData_pre;
+int HP_intif_pRecvHomunculusData_post;
+int HP_intif_pSaveHomunculusOk_pre;
+int HP_intif_pSaveHomunculusOk_post;
+int HP_intif_pDeleteHomunculusOk_pre;
+int HP_intif_pDeleteHomunculusOk_post;
+int HP_ircbot_init_pre;
+int HP_ircbot_init_post;
+int HP_ircbot_final_pre;
+int HP_ircbot_final_post;
+int HP_ircbot_parse_pre;
+int HP_ircbot_parse_post;
+int HP_ircbot_parse_sub_pre;
+int HP_ircbot_parse_sub_post;
+int HP_ircbot_parse_source_pre;
+int HP_ircbot_parse_source_post;
+int HP_ircbot_func_search_pre;
+int HP_ircbot_func_search_post;
+int HP_ircbot_connect_timer_pre;
+int HP_ircbot_connect_timer_post;
+int HP_ircbot_identify_timer_pre;
+int HP_ircbot_identify_timer_post;
+int HP_ircbot_join_timer_pre;
+int HP_ircbot_join_timer_post;
+int HP_ircbot_send_pre;
+int HP_ircbot_send_post;
+int HP_ircbot_relay_pre;
+int HP_ircbot_relay_post;
+int HP_ircbot_pong_pre;
+int HP_ircbot_pong_post;
+int HP_ircbot_privmsg_pre;
+int HP_ircbot_privmsg_post;
+int HP_ircbot_userjoin_pre;
+int HP_ircbot_userjoin_post;
+int HP_ircbot_userleave_pre;
+int HP_ircbot_userleave_post;
+int HP_ircbot_usernick_pre;
+int HP_ircbot_usernick_post;
+int HP_itemdb_init_pre;
+int HP_itemdb_init_post;
+int HP_itemdb_final_pre;
+int HP_itemdb_final_post;
+int HP_itemdb_reload_pre;
+int HP_itemdb_reload_post;
+int HP_itemdb_name_constants_pre;
+int HP_itemdb_name_constants_post;
+int HP_itemdb_force_name_constants_pre;
+int HP_itemdb_force_name_constants_post;
+int HP_itemdb_read_groups_pre;
+int HP_itemdb_read_groups_post;
+int HP_itemdb_read_chains_pre;
+int HP_itemdb_read_chains_post;
+int HP_itemdb_read_packages_pre;
+int HP_itemdb_read_packages_post;
+int HP_itemdb_write_cached_packages_pre;
+int HP_itemdb_write_cached_packages_post;
+int HP_itemdb_read_cached_packages_pre;
+int HP_itemdb_read_cached_packages_post;
+int HP_itemdb_name2id_pre;
+int HP_itemdb_name2id_post;
+int HP_itemdb_search_name_pre;
+int HP_itemdb_search_name_post;
+int HP_itemdb_search_name_array_pre;
+int HP_itemdb_search_name_array_post;
+int HP_itemdb_load_pre;
+int HP_itemdb_load_post;
+int HP_itemdb_search_pre;
+int HP_itemdb_search_post;
+int HP_itemdb_parse_dbrow_pre;
+int HP_itemdb_parse_dbrow_post;
+int HP_itemdb_exists_pre;
+int HP_itemdb_exists_post;
+int HP_itemdb_in_group_pre;
+int HP_itemdb_in_group_post;
+int HP_itemdb_group_item_pre;
+int HP_itemdb_group_item_post;
+int HP_itemdb_chain_item_pre;
+int HP_itemdb_chain_item_post;
+int HP_itemdb_package_item_pre;
+int HP_itemdb_package_item_post;
+int HP_itemdb_searchname_sub_pre;
+int HP_itemdb_searchname_sub_post;
+int HP_itemdb_searchname_array_sub_pre;
+int HP_itemdb_searchname_array_sub_post;
+int HP_itemdb_searchrandomid_pre;
+int HP_itemdb_searchrandomid_post;
+int HP_itemdb_typename_pre;
+int HP_itemdb_typename_post;
+int HP_itemdb_jobid2mapid_pre;
+int HP_itemdb_jobid2mapid_post;
+int HP_itemdb_create_dummy_data_pre;
+int HP_itemdb_create_dummy_data_post;
+int HP_itemdb_create_item_data_pre;
+int HP_itemdb_create_item_data_post;
+int HP_itemdb_isequip_pre;
+int HP_itemdb_isequip_post;
+int HP_itemdb_isequip2_pre;
+int HP_itemdb_isequip2_post;
+int HP_itemdb_isstackable_pre;
+int HP_itemdb_isstackable_post;
+int HP_itemdb_isstackable2_pre;
+int HP_itemdb_isstackable2_post;
+int HP_itemdb_isdropable_sub_pre;
+int HP_itemdb_isdropable_sub_post;
+int HP_itemdb_cantrade_sub_pre;
+int HP_itemdb_cantrade_sub_post;
+int HP_itemdb_canpartnertrade_sub_pre;
+int HP_itemdb_canpartnertrade_sub_post;
+int HP_itemdb_cansell_sub_pre;
+int HP_itemdb_cansell_sub_post;
+int HP_itemdb_cancartstore_sub_pre;
+int HP_itemdb_cancartstore_sub_post;
+int HP_itemdb_canstore_sub_pre;
+int HP_itemdb_canstore_sub_post;
+int HP_itemdb_canguildstore_sub_pre;
+int HP_itemdb_canguildstore_sub_post;
+int HP_itemdb_canmail_sub_pre;
+int HP_itemdb_canmail_sub_post;
+int HP_itemdb_canauction_sub_pre;
+int HP_itemdb_canauction_sub_post;
+int HP_itemdb_isrestricted_pre;
+int HP_itemdb_isrestricted_post;
+int HP_itemdb_isidentified_pre;
+int HP_itemdb_isidentified_post;
+int HP_itemdb_isidentified2_pre;
+int HP_itemdb_isidentified2_post;
+int HP_itemdb_read_itemavail_pre;
+int HP_itemdb_read_itemavail_post;
+int HP_itemdb_read_itemtrade_pre;
+int HP_itemdb_read_itemtrade_post;
+int HP_itemdb_read_itemdelay_pre;
+int HP_itemdb_read_itemdelay_post;
+int HP_itemdb_read_stack_pre;
+int HP_itemdb_read_stack_post;
+int HP_itemdb_read_buyingstore_pre;
+int HP_itemdb_read_buyingstore_post;
+int HP_itemdb_read_nouse_pre;
+int HP_itemdb_read_nouse_post;
+int HP_itemdb_combo_split_atoi_pre;
+int HP_itemdb_combo_split_atoi_post;
+int HP_itemdb_read_combos_pre;
+int HP_itemdb_read_combos_post;
+int HP_itemdb_gendercheck_pre;
+int HP_itemdb_gendercheck_post;
+int HP_itemdb_re_split_atoi_pre;
+int HP_itemdb_re_split_atoi_post;
+int HP_itemdb_readdb_pre;
+int HP_itemdb_readdb_post;
+int HP_itemdb_read_sqldb_pre;
+int HP_itemdb_read_sqldb_post;
+int HP_itemdb_unique_id_pre;
+int HP_itemdb_unique_id_post;
+int HP_itemdb_uid_load_pre;
+int HP_itemdb_uid_load_post;
+int HP_itemdb_read_pre;
+int HP_itemdb_read_post;
+int HP_itemdb_destroy_item_data_pre;
+int HP_itemdb_destroy_item_data_post;
+int HP_itemdb_final_sub_pre;
+int HP_itemdb_final_sub_post;
+int HP_logs_pick_pc_pre;
+int HP_logs_pick_pc_post;
+int HP_logs_pick_mob_pre;
+int HP_logs_pick_mob_post;
+int HP_logs_zeny_pre;
+int HP_logs_zeny_post;
+int HP_logs_npc_pre;
+int HP_logs_npc_post;
+int HP_logs_chat_pre;
+int HP_logs_chat_post;
+int HP_logs_atcommand_pre;
+int HP_logs_atcommand_post;
+int HP_logs_branch_pre;
+int HP_logs_branch_post;
+int HP_logs_mvpdrop_pre;
+int HP_logs_mvpdrop_post;
+int HP_logs_pick_sub_pre;
+int HP_logs_pick_sub_post;
+int HP_logs_zeny_sub_pre;
+int HP_logs_zeny_sub_post;
+int HP_logs_npc_sub_pre;
+int HP_logs_npc_sub_post;
+int HP_logs_chat_sub_pre;
+int HP_logs_chat_sub_post;
+int HP_logs_atcommand_sub_pre;
+int HP_logs_atcommand_sub_post;
+int HP_logs_branch_sub_pre;
+int HP_logs_branch_sub_post;
+int HP_logs_mvpdrop_sub_pre;
+int HP_logs_mvpdrop_sub_post;
+int HP_logs_config_read_pre;
+int HP_logs_config_read_post;
+int HP_logs_config_done_pre;
+int HP_logs_config_done_post;
+int HP_logs_sql_init_pre;
+int HP_logs_sql_init_post;
+int HP_logs_sql_final_pre;
+int HP_logs_sql_final_post;
+int HP_logs_picktype2char_pre;
+int HP_logs_picktype2char_post;
+int HP_logs_chattype2char_pre;
+int HP_logs_chattype2char_post;
+int HP_logs_should_log_item_pre;
+int HP_logs_should_log_item_post;
+int HP_mail_clear_pre;
+int HP_mail_clear_post;
+int HP_mail_removeitem_pre;
+int HP_mail_removeitem_post;
+int HP_mail_removezeny_pre;
+int HP_mail_removezeny_post;
+int HP_mail_setitem_pre;
+int HP_mail_setitem_post;
+int HP_mail_setattachment_pre;
+int HP_mail_setattachment_post;
+int HP_mail_getattachment_pre;
+int HP_mail_getattachment_post;
+int HP_mail_openmail_pre;
+int HP_mail_openmail_post;
+int HP_mail_deliveryfail_pre;
+int HP_mail_deliveryfail_post;
+int HP_mail_invalid_operation_pre;
+int HP_mail_invalid_operation_post;
+int HP_map_zone_init_pre;
+int HP_map_zone_init_post;
+int HP_map_zone_remove_pre;
+int HP_map_zone_remove_post;
+int HP_map_zone_apply_pre;
+int HP_map_zone_apply_post;
+int HP_map_zone_change_pre;
+int HP_map_zone_change_post;
+int HP_map_zone_change2_pre;
+int HP_map_zone_change2_post;
+int HP_map_getcell_pre;
+int HP_map_getcell_post;
+int HP_map_setgatcell_pre;
+int HP_map_setgatcell_post;
+int HP_map_cellfromcache_pre;
+int HP_map_cellfromcache_post;
+int HP_map_setusers_pre;
+int HP_map_setusers_post;
+int HP_map_getusers_pre;
+int HP_map_getusers_post;
+int HP_map_usercount_pre;
+int HP_map_usercount_post;
+int HP_map_freeblock_pre;
+int HP_map_freeblock_post;
+int HP_map_freeblock_lock_pre;
+int HP_map_freeblock_lock_post;
+int HP_map_freeblock_unlock_pre;
+int HP_map_freeblock_unlock_post;
+int HP_map_addblock_pre;
+int HP_map_addblock_post;
+int HP_map_delblock_pre;
+int HP_map_delblock_post;
+int HP_map_moveblock_pre;
+int HP_map_moveblock_post;
+int HP_map_count_oncell_pre;
+int HP_map_count_oncell_post;
+int HP_map_find_skill_unit_oncell_pre;
+int HP_map_find_skill_unit_oncell_post;
+int HP_map_get_new_object_id_pre;
+int HP_map_get_new_object_id_post;
+int HP_map_search_freecell_pre;
+int HP_map_search_freecell_post;
+int HP_map_quit_pre;
+int HP_map_quit_post;
+int HP_map_addnpc_pre;
+int HP_map_addnpc_post;
+int HP_map_clearflooritem_timer_pre;
+int HP_map_clearflooritem_timer_post;
+int HP_map_removemobs_timer_pre;
+int HP_map_removemobs_timer_post;
+int HP_map_clearflooritem_pre;
+int HP_map_clearflooritem_post;
+int HP_map_addflooritem_pre;
+int HP_map_addflooritem_post;
+int HP_map_addnickdb_pre;
+int HP_map_addnickdb_post;
+int HP_map_delnickdb_pre;
+int HP_map_delnickdb_post;
+int HP_map_reqnickdb_pre;
+int HP_map_reqnickdb_post;
+int HP_map_charid2nick_pre;
+int HP_map_charid2nick_post;
+int HP_map_charid2sd_pre;
+int HP_map_charid2sd_post;
+int HP_map_vforeachpc_pre;
+int HP_map_vforeachpc_post;
+int HP_map_vforeachmob_pre;
+int HP_map_vforeachmob_post;
+int HP_map_vforeachnpc_pre;
+int HP_map_vforeachnpc_post;
+int HP_map_vforeachregen_pre;
+int HP_map_vforeachregen_post;
+int HP_map_vforeachiddb_pre;
+int HP_map_vforeachiddb_post;
+int HP_map_vforeachinrange_pre;
+int HP_map_vforeachinrange_post;
+int HP_map_vforeachinshootrange_pre;
+int HP_map_vforeachinshootrange_post;
+int HP_map_vforeachinarea_pre;
+int HP_map_vforeachinarea_post;
+int HP_map_vforcountinrange_pre;
+int HP_map_vforcountinrange_post;
+int HP_map_vforcountinarea_pre;
+int HP_map_vforcountinarea_post;
+int HP_map_vforeachinmovearea_pre;
+int HP_map_vforeachinmovearea_post;
+int HP_map_vforeachincell_pre;
+int HP_map_vforeachincell_post;
+int HP_map_vforeachinpath_pre;
+int HP_map_vforeachinpath_post;
+int HP_map_vforeachinmap_pre;
+int HP_map_vforeachinmap_post;
+int HP_map_vforeachininstance_pre;
+int HP_map_vforeachininstance_post;
+int HP_map_id2sd_pre;
+int HP_map_id2sd_post;
+int HP_map_id2md_pre;
+int HP_map_id2md_post;
+int HP_map_id2nd_pre;
+int HP_map_id2nd_post;
+int HP_map_id2hd_pre;
+int HP_map_id2hd_post;
+int HP_map_id2mc_pre;
+int HP_map_id2mc_post;
+int HP_map_id2cd_pre;
+int HP_map_id2cd_post;
+int HP_map_id2bl_pre;
+int HP_map_id2bl_post;
+int HP_map_blid_exists_pre;
+int HP_map_blid_exists_post;
+int HP_map_mapindex2mapid_pre;
+int HP_map_mapindex2mapid_post;
+int HP_map_mapname2mapid_pre;
+int HP_map_mapname2mapid_post;
+int HP_map_mapname2ipport_pre;
+int HP_map_mapname2ipport_post;
+int HP_map_setipport_pre;
+int HP_map_setipport_post;
+int HP_map_eraseipport_pre;
+int HP_map_eraseipport_post;
+int HP_map_eraseallipport_pre;
+int HP_map_eraseallipport_post;
+int HP_map_addiddb_pre;
+int HP_map_addiddb_post;
+int HP_map_deliddb_pre;
+int HP_map_deliddb_post;
+int HP_map_nick2sd_pre;
+int HP_map_nick2sd_post;
+int HP_map_getmob_boss_pre;
+int HP_map_getmob_boss_post;
+int HP_map_id2boss_pre;
+int HP_map_id2boss_post;
+int HP_map_reloadnpc_pre;
+int HP_map_reloadnpc_post;
+int HP_map_check_dir_pre;
+int HP_map_check_dir_post;
+int HP_map_calc_dir_pre;
+int HP_map_calc_dir_post;
+int HP_map_random_dir_pre;
+int HP_map_random_dir_post;
+int HP_map_cleanup_sub_pre;
+int HP_map_cleanup_sub_post;
+int HP_map_delmap_pre;
+int HP_map_delmap_post;
+int HP_map_flags_init_pre;
+int HP_map_flags_init_post;
+int HP_map_iwall_set_pre;
+int HP_map_iwall_set_post;
+int HP_map_iwall_get_pre;
+int HP_map_iwall_get_post;
+int HP_map_iwall_remove_pre;
+int HP_map_iwall_remove_post;
+int HP_map_addmobtolist_pre;
+int HP_map_addmobtolist_post;
+int HP_map_spawnmobs_pre;
+int HP_map_spawnmobs_post;
+int HP_map_removemobs_pre;
+int HP_map_removemobs_post;
+int HP_map_addmap2db_pre;
+int HP_map_addmap2db_post;
+int HP_map_removemapdb_pre;
+int HP_map_removemapdb_post;
+int HP_map_clean_pre;
+int HP_map_clean_post;
+int HP_map_do_shutdown_pre;
+int HP_map_do_shutdown_post;
+int HP_map_freeblock_timer_pre;
+int HP_map_freeblock_timer_post;
+int HP_map_searchrandfreecell_pre;
+int HP_map_searchrandfreecell_post;
+int HP_map_count_sub_pre;
+int HP_map_count_sub_post;
+int HP_map_create_charid2nick_pre;
+int HP_map_create_charid2nick_post;
+int HP_map_removemobs_sub_pre;
+int HP_map_removemobs_sub_post;
+int HP_map_gat2cell_pre;
+int HP_map_gat2cell_post;
+int HP_map_cell2gat_pre;
+int HP_map_cell2gat_post;
+int HP_map_getcellp_pre;
+int HP_map_getcellp_post;
+int HP_map_setcell_pre;
+int HP_map_setcell_post;
+int HP_map_sub_getcellp_pre;
+int HP_map_sub_getcellp_post;
+int HP_map_sub_setcell_pre;
+int HP_map_sub_setcell_post;
+int HP_map_iwall_nextxy_pre;
+int HP_map_iwall_nextxy_post;
+int HP_map_create_map_data_other_server_pre;
+int HP_map_create_map_data_other_server_post;
+int HP_map_eraseallipport_sub_pre;
+int HP_map_eraseallipport_sub_post;
+int HP_map_init_mapcache_pre;
+int HP_map_init_mapcache_post;
+int HP_map_readfromcache_pre;
+int HP_map_readfromcache_post;
+int HP_map_addmap_pre;
+int HP_map_addmap_post;
+int HP_map_delmapid_pre;
+int HP_map_delmapid_post;
+int HP_map_zone_db_clear_pre;
+int HP_map_zone_db_clear_post;
+int HP_map_list_final_pre;
+int HP_map_list_final_post;
+int HP_map_waterheight_pre;
+int HP_map_waterheight_post;
+int HP_map_readgat_pre;
+int HP_map_readgat_post;
+int HP_map_readallmaps_pre;
+int HP_map_readallmaps_post;
+int HP_map_config_read_pre;
+int HP_map_config_read_post;
+int HP_map_config_read_sub_pre;
+int HP_map_config_read_sub_post;
+int HP_map_reloadnpc_sub_pre;
+int HP_map_reloadnpc_sub_post;
+int HP_map_inter_config_read_pre;
+int HP_map_inter_config_read_post;
+int HP_map_sql_init_pre;
+int HP_map_sql_init_post;
+int HP_map_sql_close_pre;
+int HP_map_sql_close_post;
+int HP_map_zone_mf_cache_pre;
+int HP_map_zone_mf_cache_post;
+int HP_map_zone_str2itemid_pre;
+int HP_map_zone_str2itemid_post;
+int HP_map_zone_str2skillid_pre;
+int HP_map_zone_str2skillid_post;
+int HP_map_zone_bl_type_pre;
+int HP_map_zone_bl_type_post;
+int HP_map_read_zone_db_pre;
+int HP_map_read_zone_db_post;
+int HP_map_db_final_pre;
+int HP_map_db_final_post;
+int HP_map_nick_db_final_pre;
+int HP_map_nick_db_final_post;
+int HP_map_cleanup_db_sub_pre;
+int HP_map_cleanup_db_sub_post;
+int HP_map_abort_sub_pre;
+int HP_map_abort_sub_post;
+int HP_map_helpscreen_pre;
+int HP_map_helpscreen_post;
+int HP_map_versionscreen_pre;
+int HP_map_versionscreen_post;
+int HP_map_arg_next_value_pre;
+int HP_map_arg_next_value_post;
+int HP_mapit_alloc_pre;
+int HP_mapit_alloc_post;
+int HP_mapit_free_pre;
+int HP_mapit_free_post;
+int HP_mapit_first_pre;
+int HP_mapit_first_post;
+int HP_mapit_last_pre;
+int HP_mapit_last_post;
+int HP_mapit_next_pre;
+int HP_mapit_next_post;
+int HP_mapit_prev_pre;
+int HP_mapit_prev_post;
+int HP_mapit_exists_pre;
+int HP_mapit_exists_post;
+int HP_mapreg_init_pre;
+int HP_mapreg_init_post;
+int HP_mapreg_final_pre;
+int HP_mapreg_final_post;
+int HP_mapreg_readreg_pre;
+int HP_mapreg_readreg_post;
+int HP_mapreg_readregstr_pre;
+int HP_mapreg_readregstr_post;
+int HP_mapreg_setreg_pre;
+int HP_mapreg_setreg_post;
+int HP_mapreg_setregstr_pre;
+int HP_mapreg_setregstr_post;
+int HP_mapreg_load_pre;
+int HP_mapreg_load_post;
+int HP_mapreg_save_pre;
+int HP_mapreg_save_post;
+int HP_mapreg_save_timer_pre;
+int HP_mapreg_save_timer_post;
+int HP_mapreg_reload_pre;
+int HP_mapreg_reload_post;
+int HP_mapreg_config_read_pre;
+int HP_mapreg_config_read_post;
+int HP_mercenary_init_pre;
+int HP_mercenary_init_post;
+int HP_mercenary_class_pre;
+int HP_mercenary_class_post;
+int HP_mercenary_get_viewdata_pre;
+int HP_mercenary_get_viewdata_post;
+int HP_mercenary_create_pre;
+int HP_mercenary_create_post;
+int HP_mercenary_data_received_pre;
+int HP_mercenary_data_received_post;
+int HP_mercenary_save_pre;
+int HP_mercenary_save_post;
+int HP_mercenary_heal_pre;
+int HP_mercenary_heal_post;
+int HP_mercenary_dead_pre;
+int HP_mercenary_dead_post;
+int HP_mercenary_delete_pre;
+int HP_mercenary_delete_post;
+int HP_mercenary_contract_stop_pre;
+int HP_mercenary_contract_stop_post;
+int HP_mercenary_get_lifetime_pre;
+int HP_mercenary_get_lifetime_post;
+int HP_mercenary_get_guild_pre;
+int HP_mercenary_get_guild_post;
+int HP_mercenary_get_faith_pre;
+int HP_mercenary_get_faith_post;
+int HP_mercenary_set_faith_pre;
+int HP_mercenary_set_faith_post;
+int HP_mercenary_get_calls_pre;
+int HP_mercenary_get_calls_post;
+int HP_mercenary_set_calls_pre;
+int HP_mercenary_set_calls_post;
+int HP_mercenary_kills_pre;
+int HP_mercenary_kills_post;
+int HP_mercenary_checkskill_pre;
+int HP_mercenary_checkskill_post;
+int HP_mercenary_read_db_pre;
+int HP_mercenary_read_db_post;
+int HP_mercenary_read_skilldb_pre;
+int HP_mercenary_read_skilldb_post;
+int HP_mercenary_killbonus_pre;
+int HP_mercenary_killbonus_post;
+int HP_mercenary_search_index_pre;
+int HP_mercenary_search_index_post;
+int HP_mercenary_contract_end_timer_pre;
+int HP_mercenary_contract_end_timer_post;
+int HP_mercenary_read_db_sub_pre;
+int HP_mercenary_read_db_sub_post;
+int HP_mercenary_read_skill_db_sub_pre;
+int HP_mercenary_read_skill_db_sub_post;
+int HP_mob_init_pre;
+int HP_mob_init_post;
+int HP_mob_final_pre;
+int HP_mob_final_post;
+int HP_mob_reload_pre;
+int HP_mob_reload_post;
+int HP_mob_db_pre;
+int HP_mob_db_post;
+int HP_mob_chat_pre;
+int HP_mob_chat_post;
+int HP_mob_makedummymobdb_pre;
+int HP_mob_makedummymobdb_post;
+int HP_mob_spawn_guardian_sub_pre;
+int HP_mob_spawn_guardian_sub_post;
+int HP_mob_skill_id2skill_idx_pre;
+int HP_mob_skill_id2skill_idx_post;
+int HP_mob_db_searchname_pre;
+int HP_mob_db_searchname_post;
+int HP_mob_db_searchname_array_sub_pre;
+int HP_mob_db_searchname_array_sub_post;
+int HP_mob_mvptomb_create_pre;
+int HP_mob_mvptomb_create_post;
+int HP_mob_mvptomb_destroy_pre;
+int HP_mob_mvptomb_destroy_post;
+int HP_mob_db_searchname_array_pre;
+int HP_mob_db_searchname_array_post;
+int HP_mob_db_checkid_pre;
+int HP_mob_db_checkid_post;
+int HP_mob_get_viewdata_pre;
+int HP_mob_get_viewdata_post;
+int HP_mob_parse_dataset_pre;
+int HP_mob_parse_dataset_post;
+int HP_mob_spawn_dataset_pre;
+int HP_mob_spawn_dataset_post;
+int HP_mob_get_random_id_pre;
+int HP_mob_get_random_id_post;
+int HP_mob_ksprotected_pre;
+int HP_mob_ksprotected_post;
+int HP_mob_once_spawn_sub_pre;
+int HP_mob_once_spawn_sub_post;
+int HP_mob_once_spawn_pre;
+int HP_mob_once_spawn_post;
+int HP_mob_once_spawn_area_pre;
+int HP_mob_once_spawn_area_post;
+int HP_mob_spawn_guardian_pre;
+int HP_mob_spawn_guardian_post;
+int HP_mob_spawn_bg_pre;
+int HP_mob_spawn_bg_post;
+int HP_mob_can_reach_pre;
+int HP_mob_can_reach_post;
+int HP_mob_linksearch_pre;
+int HP_mob_linksearch_post;
+int HP_mob_delayspawn_pre;
+int HP_mob_delayspawn_post;
+int HP_mob_setdelayspawn_pre;
+int HP_mob_setdelayspawn_post;
+int HP_mob_count_sub_pre;
+int HP_mob_count_sub_post;
+int HP_mob_spawn_pre;
+int HP_mob_spawn_post;
+int HP_mob_can_changetarget_pre;
+int HP_mob_can_changetarget_post;
+int HP_mob_target_pre;
+int HP_mob_target_post;
+int HP_mob_ai_sub_hard_activesearch_pre;
+int HP_mob_ai_sub_hard_activesearch_post;
+int HP_mob_ai_sub_hard_changechase_pre;
+int HP_mob_ai_sub_hard_changechase_post;
+int HP_mob_ai_sub_hard_bg_ally_pre;
+int HP_mob_ai_sub_hard_bg_ally_post;
+int HP_mob_ai_sub_hard_lootsearch_pre;
+int HP_mob_ai_sub_hard_lootsearch_post;
+int HP_mob_warpchase_sub_pre;
+int HP_mob_warpchase_sub_post;
+int HP_mob_ai_sub_hard_slavemob_pre;
+int HP_mob_ai_sub_hard_slavemob_post;
+int HP_mob_unlocktarget_pre;
+int HP_mob_unlocktarget_post;
+int HP_mob_randomwalk_pre;
+int HP_mob_randomwalk_post;
+int HP_mob_warpchase_pre;
+int HP_mob_warpchase_post;
+int HP_mob_ai_sub_hard_pre;
+int HP_mob_ai_sub_hard_post;
+int HP_mob_ai_sub_hard_timer_pre;
+int HP_mob_ai_sub_hard_timer_post;
+int HP_mob_ai_sub_foreachclient_pre;
+int HP_mob_ai_sub_foreachclient_post;
+int HP_mob_ai_sub_lazy_pre;
+int HP_mob_ai_sub_lazy_post;
+int HP_mob_ai_lazy_pre;
+int HP_mob_ai_lazy_post;
+int HP_mob_ai_hard_pre;
+int HP_mob_ai_hard_post;
+int HP_mob_setdropitem_pre;
+int HP_mob_setdropitem_post;
+int HP_mob_setlootitem_pre;
+int HP_mob_setlootitem_post;
+int HP_mob_delay_item_drop_pre;
+int HP_mob_delay_item_drop_post;
+int HP_mob_item_drop_pre;
+int HP_mob_item_drop_post;
+int HP_mob_timer_delete_pre;
+int HP_mob_timer_delete_post;
+int HP_mob_deleteslave_sub_pre;
+int HP_mob_deleteslave_sub_post;
+int HP_mob_deleteslave_pre;
+int HP_mob_deleteslave_post;
+int HP_mob_respawn_pre;
+int HP_mob_respawn_post;
+int HP_mob_log_damage_pre;
+int HP_mob_log_damage_post;
+int HP_mob_damage_pre;
+int HP_mob_damage_post;
+int HP_mob_dead_pre;
+int HP_mob_dead_post;
+int HP_mob_revive_pre;
+int HP_mob_revive_post;
+int HP_mob_guardian_guildchange_pre;
+int HP_mob_guardian_guildchange_post;
+int HP_mob_random_class_pre;
+int HP_mob_random_class_post;
+int HP_mob_class_change_pre;
+int HP_mob_class_change_post;
+int HP_mob_heal_pre;
+int HP_mob_heal_post;
+int HP_mob_warpslave_sub_pre;
+int HP_mob_warpslave_sub_post;
+int HP_mob_warpslave_pre;
+int HP_mob_warpslave_post;
+int HP_mob_countslave_sub_pre;
+int HP_mob_countslave_sub_post;
+int HP_mob_countslave_pre;
+int HP_mob_countslave_post;
+int HP_mob_summonslave_pre;
+int HP_mob_summonslave_post;
+int HP_mob_getfriendhprate_sub_pre;
+int HP_mob_getfriendhprate_sub_post;
+int HP_mob_getfriendhprate_pre;
+int HP_mob_getfriendhprate_post;
+int HP_mob_getmasterhpltmaxrate_pre;
+int HP_mob_getmasterhpltmaxrate_post;
+int HP_mob_getfriendstatus_sub_pre;
+int HP_mob_getfriendstatus_sub_post;
+int HP_mob_getfriendstatus_pre;
+int HP_mob_getfriendstatus_post;
+int HP_mob_skill_use_pre;
+int HP_mob_skill_use_post;
+int HP_mob_skill_event_pre;
+int HP_mob_skill_event_post;
+int HP_mob_is_clone_pre;
+int HP_mob_is_clone_post;
+int HP_mob_clone_spawn_pre;
+int HP_mob_clone_spawn_post;
+int HP_mob_clone_delete_pre;
+int HP_mob_clone_delete_post;
+int HP_mob_drop_adjust_pre;
+int HP_mob_drop_adjust_post;
+int HP_mob_item_dropratio_adjust_pre;
+int HP_mob_item_dropratio_adjust_post;
+int HP_mob_parse_dbrow_pre;
+int HP_mob_parse_dbrow_post;
+int HP_mob_readdb_sub_pre;
+int HP_mob_readdb_sub_post;
+int HP_mob_readdb_pre;
+int HP_mob_readdb_post;
+int HP_mob_read_sqldb_pre;
+int HP_mob_read_sqldb_post;
+int HP_mob_readdb_mobavail_pre;
+int HP_mob_readdb_mobavail_post;
+int HP_mob_read_randommonster_pre;
+int HP_mob_read_randommonster_post;
+int HP_mob_parse_row_chatdb_pre;
+int HP_mob_parse_row_chatdb_post;
+int HP_mob_readchatdb_pre;
+int HP_mob_readchatdb_post;
+int HP_mob_parse_row_mobskilldb_pre;
+int HP_mob_parse_row_mobskilldb_post;
+int HP_mob_readskilldb_pre;
+int HP_mob_readskilldb_post;
+int HP_mob_read_sqlskilldb_pre;
+int HP_mob_read_sqlskilldb_post;
+int HP_mob_readdb_race2_pre;
+int HP_mob_readdb_race2_post;
+int HP_mob_readdb_itemratio_pre;
+int HP_mob_readdb_itemratio_post;
+int HP_mob_load_pre;
+int HP_mob_load_post;
+int HP_mob_clear_spawninfo_pre;
+int HP_mob_clear_spawninfo_post;
+int HP_npc_init_pre;
+int HP_npc_init_post;
+int HP_npc_final_pre;
+int HP_npc_final_post;
+int HP_npc_get_new_npc_id_pre;
+int HP_npc_get_new_npc_id_post;
+int HP_npc_get_viewdata_pre;
+int HP_npc_get_viewdata_post;
+int HP_npc_isnear_sub_pre;
+int HP_npc_isnear_sub_post;
+int HP_npc_isnear_pre;
+int HP_npc_isnear_post;
+int HP_npc_ontouch_event_pre;
+int HP_npc_ontouch_event_post;
+int HP_npc_ontouch2_event_pre;
+int HP_npc_ontouch2_event_post;
+int HP_npc_enable_sub_pre;
+int HP_npc_enable_sub_post;
+int HP_npc_enable_pre;
+int HP_npc_enable_post;
+int HP_npc_name2id_pre;
+int HP_npc_name2id_post;
+int HP_npc_event_dequeue_pre;
+int HP_npc_event_dequeue_post;
+int HP_npc_event_export_create_pre;
+int HP_npc_event_export_create_post;
+int HP_npc_event_export_pre;
+int HP_npc_event_export_post;
+int HP_npc_event_sub_pre;
+int HP_npc_event_sub_post;
+int HP_npc_event_doall_sub_pre;
+int HP_npc_event_doall_sub_post;
+int HP_npc_event_do_pre;
+int HP_npc_event_do_post;
+int HP_npc_event_doall_id_pre;
+int HP_npc_event_doall_id_post;
+int HP_npc_event_doall_pre;
+int HP_npc_event_doall_post;
+int HP_npc_event_do_clock_pre;
+int HP_npc_event_do_clock_post;
+int HP_npc_event_do_oninit_pre;
+int HP_npc_event_do_oninit_post;
+int HP_npc_timerevent_export_pre;
+int HP_npc_timerevent_export_post;
+int HP_npc_timerevent_pre;
+int HP_npc_timerevent_post;
+int HP_npc_timerevent_start_pre;
+int HP_npc_timerevent_start_post;
+int HP_npc_timerevent_stop_pre;
+int HP_npc_timerevent_stop_post;
+int HP_npc_timerevent_quit_pre;
+int HP_npc_timerevent_quit_post;
+int HP_npc_gettimerevent_tick_pre;
+int HP_npc_gettimerevent_tick_post;
+int HP_npc_settimerevent_tick_pre;
+int HP_npc_settimerevent_tick_post;
+int HP_npc_event_pre;
+int HP_npc_event_post;
+int HP_npc_touch_areanpc_sub_pre;
+int HP_npc_touch_areanpc_sub_post;
+int HP_npc_touchnext_areanpc_pre;
+int HP_npc_touchnext_areanpc_post;
+int HP_npc_touch_areanpc_pre;
+int HP_npc_touch_areanpc_post;
+int HP_npc_touch_areanpc2_pre;
+int HP_npc_touch_areanpc2_post;
+int HP_npc_check_areanpc_pre;
+int HP_npc_check_areanpc_post;
+int HP_npc_checknear_pre;
+int HP_npc_checknear_post;
+int HP_npc_globalmessage_pre;
+int HP_npc_globalmessage_post;
+int HP_npc_run_tomb_pre;
+int HP_npc_run_tomb_post;
+int HP_npc_click_pre;
+int HP_npc_click_post;
+int HP_npc_scriptcont_pre;
+int HP_npc_scriptcont_post;
+int HP_npc_buysellsel_pre;
+int HP_npc_buysellsel_post;
+int HP_npc_cashshop_buylist_pre;
+int HP_npc_cashshop_buylist_post;
+int HP_npc_buylist_sub_pre;
+int HP_npc_buylist_sub_post;
+int HP_npc_cashshop_buy_pre;
+int HP_npc_cashshop_buy_post;
+int HP_npc_buylist_pre;
+int HP_npc_buylist_post;
+int HP_npc_selllist_sub_pre;
+int HP_npc_selllist_sub_post;
+int HP_npc_selllist_pre;
+int HP_npc_selllist_post;
+int HP_npc_remove_map_pre;
+int HP_npc_remove_map_post;
+int HP_npc_unload_ev_pre;
+int HP_npc_unload_ev_post;
+int HP_npc_unload_ev_label_pre;
+int HP_npc_unload_ev_label_post;
+int HP_npc_unload_dup_sub_pre;
+int HP_npc_unload_dup_sub_post;
+int HP_npc_unload_duplicates_pre;
+int HP_npc_unload_duplicates_post;
+int HP_npc_unload_pre;
+int HP_npc_unload_post;
+int HP_npc_clearsrcfile_pre;
+int HP_npc_clearsrcfile_post;
+int HP_npc_addsrcfile_pre;
+int HP_npc_addsrcfile_post;
+int HP_npc_delsrcfile_pre;
+int HP_npc_delsrcfile_post;
+int HP_npc_parsename_pre;
+int HP_npc_parsename_post;
+int HP_npc_add_warp_pre;
+int HP_npc_add_warp_post;
+int HP_npc_parse_warp_pre;
+int HP_npc_parse_warp_post;
+int HP_npc_parse_shop_pre;
+int HP_npc_parse_shop_post;
+int HP_npc_convertlabel_db_pre;
+int HP_npc_convertlabel_db_post;
+int HP_npc_skip_script_pre;
+int HP_npc_skip_script_post;
+int HP_npc_parse_script_pre;
+int HP_npc_parse_script_post;
+int HP_npc_parse_duplicate_pre;
+int HP_npc_parse_duplicate_post;
+int HP_npc_duplicate4instance_pre;
+int HP_npc_duplicate4instance_post;
+int HP_npc_setcells_pre;
+int HP_npc_setcells_post;
+int HP_npc_unsetcells_sub_pre;
+int HP_npc_unsetcells_sub_post;
+int HP_npc_unsetcells_pre;
+int HP_npc_unsetcells_post;
+int HP_npc_movenpc_pre;
+int HP_npc_movenpc_post;
+int HP_npc_setdisplayname_pre;
+int HP_npc_setdisplayname_post;
+int HP_npc_setclass_pre;
+int HP_npc_setclass_post;
+int HP_npc_do_atcmd_event_pre;
+int HP_npc_do_atcmd_event_post;
+int HP_npc_parse_function_pre;
+int HP_npc_parse_function_post;
+int HP_npc_parse_mob2_pre;
+int HP_npc_parse_mob2_post;
+int HP_npc_parse_mob_pre;
+int HP_npc_parse_mob_post;
+int HP_npc_parse_mapflag_pre;
+int HP_npc_parse_mapflag_post;
+int HP_npc_parsesrcfile_pre;
+int HP_npc_parsesrcfile_post;
+int HP_npc_script_event_pre;
+int HP_npc_script_event_post;
+int HP_npc_read_event_script_pre;
+int HP_npc_read_event_script_post;
+int HP_npc_path_db_clear_sub_pre;
+int HP_npc_path_db_clear_sub_post;
+int HP_npc_ev_label_db_clear_sub_pre;
+int HP_npc_ev_label_db_clear_sub_post;
+int HP_npc_reload_pre;
+int HP_npc_reload_post;
+int HP_npc_unloadfile_pre;
+int HP_npc_unloadfile_post;
+int HP_npc_do_clear_npc_pre;
+int HP_npc_do_clear_npc_post;
+int HP_npc_debug_warps_sub_pre;
+int HP_npc_debug_warps_sub_post;
+int HP_npc_debug_warps_pre;
+int HP_npc_debug_warps_post;
+int HP_party_init_pre;
+int HP_party_init_post;
+int HP_party_final_pre;
+int HP_party_final_post;
+int HP_party_search_pre;
+int HP_party_search_post;
+int HP_party_searchname_pre;
+int HP_party_searchname_post;
+int HP_party_getmemberid_pre;
+int HP_party_getmemberid_post;
+int HP_party_getavailablesd_pre;
+int HP_party_getavailablesd_post;
+int HP_party_create_pre;
+int HP_party_create_post;
+int HP_party_created_pre;
+int HP_party_created_post;
+int HP_party_request_info_pre;
+int HP_party_request_info_post;
+int HP_party_invite_pre;
+int HP_party_invite_post;
+int HP_party_member_joined_pre;
+int HP_party_member_joined_post;
+int HP_party_member_added_pre;
+int HP_party_member_added_post;
+int HP_party_leave_pre;
+int HP_party_leave_post;
+int HP_party_removemember_pre;
+int HP_party_removemember_post;
+int HP_party_member_withdraw_pre;
+int HP_party_member_withdraw_post;
+int HP_party_reply_invite_pre;
+int HP_party_reply_invite_post;
+int HP_party_recv_noinfo_pre;
+int HP_party_recv_noinfo_post;
+int HP_party_recv_info_pre;
+int HP_party_recv_info_post;
+int HP_party_recv_movemap_pre;
+int HP_party_recv_movemap_post;
+int HP_party_broken_pre;
+int HP_party_broken_post;
+int HP_party_optionchanged_pre;
+int HP_party_optionchanged_post;
+int HP_party_changeoption_pre;
+int HP_party_changeoption_post;
+int HP_party_changeleader_pre;
+int HP_party_changeleader_post;
+int HP_party_send_movemap_pre;
+int HP_party_send_movemap_post;
+int HP_party_send_levelup_pre;
+int HP_party_send_levelup_post;
+int HP_party_send_logout_pre;
+int HP_party_send_logout_post;
+int HP_party_send_message_pre;
+int HP_party_send_message_post;
+int HP_party_recv_message_pre;
+int HP_party_recv_message_post;
+int HP_party_skill_check_pre;
+int HP_party_skill_check_post;
+int HP_party_send_xy_clear_pre;
+int HP_party_send_xy_clear_post;
+int HP_party_exp_share_pre;
+int HP_party_exp_share_post;
+int HP_party_share_loot_pre;
+int HP_party_share_loot_post;
+int HP_party_send_dot_remove_pre;
+int HP_party_send_dot_remove_post;
+int HP_party_sub_count_pre;
+int HP_party_sub_count_post;
+int HP_party_booking_register_pre;
+int HP_party_booking_register_post;
+int HP_party_booking_update_pre;
+int HP_party_booking_update_post;
+int HP_party_booking_search_pre;
+int HP_party_booking_search_post;
+int HP_party_booking_delete_pre;
+int HP_party_booking_delete_post;
+int HP_party_vforeachsamemap_pre;
+int HP_party_vforeachsamemap_post;
+int HP_party_send_xy_timer_pre;
+int HP_party_send_xy_timer_post;
+int HP_party_fill_member_pre;
+int HP_party_fill_member_post;
+int HP_party_sd_check_pre;
+int HP_party_sd_check_post;
+int HP_party_check_state_pre;
+int HP_party_check_state_post;
+int HP_party_create_booking_data_pre;
+int HP_party_create_booking_data_post;
+int HP_party_db_final_pre;
+int HP_party_db_final_post;
+int HP_path_blownpos_pre;
+int HP_path_blownpos_post;
+int HP_path_search_pre;
+int HP_path_search_post;
+int HP_path_search_long_pre;
+int HP_path_search_long_post;
+int HP_path_check_distance_pre;
+int HP_path_check_distance_post;
+int HP_path_distance_pre;
+int HP_path_distance_post;
+int HP_pc_init_pre;
+int HP_pc_init_post;
+int HP_pc_final_pre;
+int HP_pc_final_post;
+int HP_pc_get_dummy_sd_pre;
+int HP_pc_get_dummy_sd_post;
+int HP_pc_class2idx_pre;
+int HP_pc_class2idx_post;
+int HP_pc_get_group_level_pre;
+int HP_pc_get_group_level_post;
+int HP_pc_can_give_items_pre;
+int HP_pc_can_give_items_post;
+int HP_pc_can_use_command_pre;
+int HP_pc_can_use_command_post;
+int HP_pc_has_permission_pre;
+int HP_pc_has_permission_post;
+int HP_pc_set_group_pre;
+int HP_pc_set_group_post;
+int HP_pc_should_log_commands_pre;
+int HP_pc_should_log_commands_post;
+int HP_pc_setrestartvalue_pre;
+int HP_pc_setrestartvalue_post;
+int HP_pc_makesavestatus_pre;
+int HP_pc_makesavestatus_post;
+int HP_pc_respawn_pre;
+int HP_pc_respawn_post;
+int HP_pc_setnewpc_pre;
+int HP_pc_setnewpc_post;
+int HP_pc_authok_pre;
+int HP_pc_authok_post;
+int HP_pc_authfail_pre;
+int HP_pc_authfail_post;
+int HP_pc_reg_received_pre;
+int HP_pc_reg_received_post;
+int HP_pc_isequip_pre;
+int HP_pc_isequip_post;
+int HP_pc_equippoint_pre;
+int HP_pc_equippoint_post;
+int HP_pc_setinventorydata_pre;
+int HP_pc_setinventorydata_post;
+int HP_pc_checkskill_pre;
+int HP_pc_checkskill_post;
+int HP_pc_checkskill2_pre;
+int HP_pc_checkskill2_post;
+int HP_pc_checkallowskill_pre;
+int HP_pc_checkallowskill_post;
+int HP_pc_checkequip_pre;
+int HP_pc_checkequip_post;
+int HP_pc_calc_skilltree_pre;
+int HP_pc_calc_skilltree_post;
+int HP_pc_calc_skilltree_normalize_job_pre;
+int HP_pc_calc_skilltree_normalize_job_post;
+int HP_pc_clean_skilltree_pre;
+int HP_pc_clean_skilltree_post;
+int HP_pc_setpos_pre;
+int HP_pc_setpos_post;
+int HP_pc_setsavepoint_pre;
+int HP_pc_setsavepoint_post;
+int HP_pc_randomwarp_pre;
+int HP_pc_randomwarp_post;
+int HP_pc_memo_pre;
+int HP_pc_memo_post;
+int HP_pc_checkadditem_pre;
+int HP_pc_checkadditem_post;
+int HP_pc_inventoryblank_pre;
+int HP_pc_inventoryblank_post;
+int HP_pc_search_inventory_pre;
+int HP_pc_search_inventory_post;
+int HP_pc_payzeny_pre;
+int HP_pc_payzeny_post;
+int HP_pc_additem_pre;
+int HP_pc_additem_post;
+int HP_pc_getzeny_pre;
+int HP_pc_getzeny_post;
+int HP_pc_delitem_pre;
+int HP_pc_delitem_post;
+int HP_pc_paycash_pre;
+int HP_pc_paycash_post;
+int HP_pc_getcash_pre;
+int HP_pc_getcash_post;
+int HP_pc_cart_additem_pre;
+int HP_pc_cart_additem_post;
+int HP_pc_cart_delitem_pre;
+int HP_pc_cart_delitem_post;
+int HP_pc_putitemtocart_pre;
+int HP_pc_putitemtocart_post;
+int HP_pc_getitemfromcart_pre;
+int HP_pc_getitemfromcart_post;
+int HP_pc_cartitem_amount_pre;
+int HP_pc_cartitem_amount_post;
+int HP_pc_takeitem_pre;
+int HP_pc_takeitem_post;
+int HP_pc_dropitem_pre;
+int HP_pc_dropitem_post;
+int HP_pc_isequipped_pre;
+int HP_pc_isequipped_post;
+int HP_pc_can_Adopt_pre;
+int HP_pc_can_Adopt_post;
+int HP_pc_adoption_pre;
+int HP_pc_adoption_post;
+int HP_pc_updateweightstatus_pre;
+int HP_pc_updateweightstatus_post;
+int HP_pc_addautobonus_pre;
+int HP_pc_addautobonus_post;
+int HP_pc_exeautobonus_pre;
+int HP_pc_exeautobonus_post;
+int HP_pc_endautobonus_pre;
+int HP_pc_endautobonus_post;
+int HP_pc_delautobonus_pre;
+int HP_pc_delautobonus_post;
+int HP_pc_bonus_pre;
+int HP_pc_bonus_post;
+int HP_pc_bonus2_pre;
+int HP_pc_bonus2_post;
+int HP_pc_bonus3_pre;
+int HP_pc_bonus3_post;
+int HP_pc_bonus4_pre;
+int HP_pc_bonus4_post;
+int HP_pc_bonus5_pre;
+int HP_pc_bonus5_post;
+int HP_pc_skill_pre;
+int HP_pc_skill_post;
+int HP_pc_insert_card_pre;
+int HP_pc_insert_card_post;
+int HP_pc_steal_item_pre;
+int HP_pc_steal_item_post;
+int HP_pc_steal_coin_pre;
+int HP_pc_steal_coin_post;
+int HP_pc_modifybuyvalue_pre;
+int HP_pc_modifybuyvalue_post;
+int HP_pc_modifysellvalue_pre;
+int HP_pc_modifysellvalue_post;
+int HP_pc_follow_pre;
+int HP_pc_follow_post;
+int HP_pc_stop_following_pre;
+int HP_pc_stop_following_post;
+int HP_pc_maxbaselv_pre;
+int HP_pc_maxbaselv_post;
+int HP_pc_maxjoblv_pre;
+int HP_pc_maxjoblv_post;
+int HP_pc_checkbaselevelup_pre;
+int HP_pc_checkbaselevelup_post;
+int HP_pc_checkjoblevelup_pre;
+int HP_pc_checkjoblevelup_post;
+int HP_pc_gainexp_pre;
+int HP_pc_gainexp_post;
+int HP_pc_nextbaseexp_pre;
+int HP_pc_nextbaseexp_post;
+int HP_pc_thisbaseexp_pre;
+int HP_pc_thisbaseexp_post;
+int HP_pc_nextjobexp_pre;
+int HP_pc_nextjobexp_post;
+int HP_pc_thisjobexp_pre;
+int HP_pc_thisjobexp_post;
+int HP_pc_gets_status_point_pre;
+int HP_pc_gets_status_point_post;
+int HP_pc_need_status_point_pre;
+int HP_pc_need_status_point_post;
+int HP_pc_statusup_pre;
+int HP_pc_statusup_post;
+int HP_pc_statusup2_pre;
+int HP_pc_statusup2_post;
+int HP_pc_skillup_pre;
+int HP_pc_skillup_post;
+int HP_pc_allskillup_pre;
+int HP_pc_allskillup_post;
+int HP_pc_resetlvl_pre;
+int HP_pc_resetlvl_post;
+int HP_pc_resetstate_pre;
+int HP_pc_resetstate_post;
+int HP_pc_resetskill_pre;
+int HP_pc_resetskill_post;
+int HP_pc_resetfeel_pre;
+int HP_pc_resetfeel_post;
+int HP_pc_resethate_pre;
+int HP_pc_resethate_post;
+int HP_pc_equipitem_pre;
+int HP_pc_equipitem_post;
+int HP_pc_unequipitem_pre;
+int HP_pc_unequipitem_post;
+int HP_pc_checkitem_pre;
+int HP_pc_checkitem_post;
+int HP_pc_useitem_pre;
+int HP_pc_useitem_post;
+int HP_pc_skillatk_bonus_pre;
+int HP_pc_skillatk_bonus_post;
+int HP_pc_skillheal_bonus_pre;
+int HP_pc_skillheal_bonus_post;
+int HP_pc_skillheal2_bonus_pre;
+int HP_pc_skillheal2_bonus_post;
+int HP_pc_damage_pre;
+int HP_pc_damage_post;
+int HP_pc_dead_pre;
+int HP_pc_dead_post;
+int HP_pc_revive_pre;
+int HP_pc_revive_post;
+int HP_pc_heal_pre;
+int HP_pc_heal_post;
+int HP_pc_itemheal_pre;
+int HP_pc_itemheal_post;
+int HP_pc_percentheal_pre;
+int HP_pc_percentheal_post;
+int HP_pc_jobchange_pre;
+int HP_pc_jobchange_post;
+int HP_pc_setoption_pre;
+int HP_pc_setoption_post;
+int HP_pc_setcart_pre;
+int HP_pc_setcart_post;
+int HP_pc_setfalcon_pre;
+int HP_pc_setfalcon_post;
+int HP_pc_setriding_pre;
+int HP_pc_setriding_post;
+int HP_pc_setmadogear_pre;
+int HP_pc_setmadogear_post;
+int HP_pc_changelook_pre;
+int HP_pc_changelook_post;
+int HP_pc_equiplookall_pre;
+int HP_pc_equiplookall_post;
+int HP_pc_readparam_pre;
+int HP_pc_readparam_post;
+int HP_pc_setparam_pre;
+int HP_pc_setparam_post;
+int HP_pc_readreg_pre;
+int HP_pc_readreg_post;
+int HP_pc_setreg_pre;
+int HP_pc_setreg_post;
+int HP_pc_readregstr_pre;
+int HP_pc_readregstr_post;
+int HP_pc_setregstr_pre;
+int HP_pc_setregstr_post;
+int HP_pc_readregistry_pre;
+int HP_pc_readregistry_post;
+int HP_pc_setregistry_pre;
+int HP_pc_setregistry_post;
+int HP_pc_readregistry_str_pre;
+int HP_pc_readregistry_str_post;
+int HP_pc_setregistry_str_pre;
+int HP_pc_setregistry_str_post;
+int HP_pc_addeventtimer_pre;
+int HP_pc_addeventtimer_post;
+int HP_pc_deleventtimer_pre;
+int HP_pc_deleventtimer_post;
+int HP_pc_cleareventtimer_pre;
+int HP_pc_cleareventtimer_post;
+int HP_pc_addeventtimercount_pre;
+int HP_pc_addeventtimercount_post;
+int HP_pc_calc_pvprank_pre;
+int HP_pc_calc_pvprank_post;
+int HP_pc_calc_pvprank_timer_pre;
+int HP_pc_calc_pvprank_timer_post;
+int HP_pc_ismarried_pre;
+int HP_pc_ismarried_post;
+int HP_pc_marriage_pre;
+int HP_pc_marriage_post;
+int HP_pc_divorce_pre;
+int HP_pc_divorce_post;
+int HP_pc_get_partner_pre;
+int HP_pc_get_partner_post;
+int HP_pc_get_father_pre;
+int HP_pc_get_father_post;
+int HP_pc_get_mother_pre;
+int HP_pc_get_mother_post;
+int HP_pc_get_child_pre;
+int HP_pc_get_child_post;
+int HP_pc_bleeding_pre;
+int HP_pc_bleeding_post;
+int HP_pc_regen_pre;
+int HP_pc_regen_post;
+int HP_pc_setstand_pre;
+int HP_pc_setstand_post;
+int HP_pc_candrop_pre;
+int HP_pc_candrop_post;
+int HP_pc_jobid2mapid_pre;
+int HP_pc_jobid2mapid_post;
+int HP_pc_mapid2jobid_pre;
+int HP_pc_mapid2jobid_post;
+int HP_pc_job_name_pre;
+int HP_pc_job_name_post;
+int HP_pc_setinvincibletimer_pre;
+int HP_pc_setinvincibletimer_post;
+int HP_pc_delinvincibletimer_pre;
+int HP_pc_delinvincibletimer_post;
+int HP_pc_addspiritball_pre;
+int HP_pc_addspiritball_post;
+int HP_pc_delspiritball_pre;
+int HP_pc_delspiritball_post;
+int HP_pc_addfame_pre;
+int HP_pc_addfame_post;
+int HP_pc_famerank_pre;
+int HP_pc_famerank_post;
+int HP_pc_set_hate_mob_pre;
+int HP_pc_set_hate_mob_post;
+int HP_pc_readdb_pre;
+int HP_pc_readdb_post;
+int HP_pc_map_day_timer_pre;
+int HP_pc_map_day_timer_post;
+int HP_pc_map_night_timer_pre;
+int HP_pc_map_night_timer_post;
+int HP_pc_inventory_rentals_pre;
+int HP_pc_inventory_rentals_post;
+int HP_pc_inventory_rental_clear_pre;
+int HP_pc_inventory_rental_clear_post;
+int HP_pc_inventory_rental_add_pre;
+int HP_pc_inventory_rental_add_post;
+int HP_pc_disguise_pre;
+int HP_pc_disguise_post;
+int HP_pc_isautolooting_pre;
+int HP_pc_isautolooting_post;
+int HP_pc_overheat_pre;
+int HP_pc_overheat_post;
+int HP_pc_banding_pre;
+int HP_pc_banding_post;
+int HP_pc_itemcd_do_pre;
+int HP_pc_itemcd_do_post;
+int HP_pc_load_combo_pre;
+int HP_pc_load_combo_post;
+int HP_pc_add_charm_pre;
+int HP_pc_add_charm_post;
+int HP_pc_del_charm_pre;
+int HP_pc_del_charm_post;
+int HP_pc_baselevelchanged_pre;
+int HP_pc_baselevelchanged_post;
+int HP_pc_level_penalty_mod_pre;
+int HP_pc_level_penalty_mod_post;
+int HP_pc_calc_skillpoint_pre;
+int HP_pc_calc_skillpoint_post;
+int HP_pc_invincible_timer_pre;
+int HP_pc_invincible_timer_post;
+int HP_pc_spiritball_timer_pre;
+int HP_pc_spiritball_timer_post;
+int HP_pc_check_banding_pre;
+int HP_pc_check_banding_post;
+int HP_pc_inventory_rental_end_pre;
+int HP_pc_inventory_rental_end_post;
+int HP_pc_check_skilltree_pre;
+int HP_pc_check_skilltree_post;
+int HP_pc_bonus_autospell_pre;
+int HP_pc_bonus_autospell_post;
+int HP_pc_bonus_autospell_onskill_pre;
+int HP_pc_bonus_autospell_onskill_post;
+int HP_pc_bonus_addeff_pre;
+int HP_pc_bonus_addeff_post;
+int HP_pc_bonus_addeff_onskill_pre;
+int HP_pc_bonus_addeff_onskill_post;
+int HP_pc_bonus_item_drop_pre;
+int HP_pc_bonus_item_drop_post;
+int HP_pc_calcexp_pre;
+int HP_pc_calcexp_post;
+int HP_pc_respawn_timer_pre;
+int HP_pc_respawn_timer_post;
+int HP_pc_jobchange_killclone_pre;
+int HP_pc_jobchange_killclone_post;
+int HP_pc_getstat_pre;
+int HP_pc_getstat_post;
+int HP_pc_setstat_pre;
+int HP_pc_setstat_post;
+int HP_pc_eventtimer_pre;
+int HP_pc_eventtimer_post;
+int HP_pc_daynight_timer_sub_pre;
+int HP_pc_daynight_timer_sub_post;
+int HP_pc_charm_timer_pre;
+int HP_pc_charm_timer_post;
+int HP_pc_readdb_levelpenalty_pre;
+int HP_pc_readdb_levelpenalty_post;
+int HP_pc_autosave_pre;
+int HP_pc_autosave_post;
+int HP_pc_follow_timer_pre;
+int HP_pc_follow_timer_post;
+int HP_pc_read_skill_tree_pre;
+int HP_pc_read_skill_tree_post;
+int HP_pc_isUseitem_pre;
+int HP_pc_isUseitem_post;
+int HP_pc_show_steal_pre;
+int HP_pc_show_steal_post;
+int HP_pc_checkcombo_pre;
+int HP_pc_checkcombo_post;
+int HP_pc_calcweapontype_pre;
+int HP_pc_calcweapontype_post;
+int HP_pc_removecombo_pre;
+int HP_pc_removecombo_post;
+int HP_pet_init_pre;
+int HP_pet_init_post;
+int HP_pet_final_pre;
+int HP_pet_final_post;
+int HP_pet_hungry_val_pre;
+int HP_pet_hungry_val_post;
+int HP_pet_set_intimate_pre;
+int HP_pet_set_intimate_post;
+int HP_pet_create_egg_pre;
+int HP_pet_create_egg_post;
+int HP_pet_unlocktarget_pre;
+int HP_pet_unlocktarget_post;
+int HP_pet_attackskill_pre;
+int HP_pet_attackskill_post;
+int HP_pet_target_check_pre;
+int HP_pet_target_check_post;
+int HP_pet_sc_check_pre;
+int HP_pet_sc_check_post;
+int HP_pet_hungry_pre;
+int HP_pet_hungry_post;
+int HP_pet_search_petDB_index_pre;
+int HP_pet_search_petDB_index_post;
+int HP_pet_hungry_timer_delete_pre;
+int HP_pet_hungry_timer_delete_post;
+int HP_pet_performance_pre;
+int HP_pet_performance_post;
+int HP_pet_return_egg_pre;
+int HP_pet_return_egg_post;
+int HP_pet_data_init_pre;
+int HP_pet_data_init_post;
+int HP_pet_birth_process_pre;
+int HP_pet_birth_process_post;
+int HP_pet_recv_petdata_pre;
+int HP_pet_recv_petdata_post;
+int HP_pet_select_egg_pre;
+int HP_pet_select_egg_post;
+int HP_pet_catch_process1_pre;
+int HP_pet_catch_process1_post;
+int HP_pet_catch_process2_pre;
+int HP_pet_catch_process2_post;
+int HP_pet_get_egg_pre;
+int HP_pet_get_egg_post;
+int HP_pet_unequipitem_pre;
+int HP_pet_unequipitem_post;
+int HP_pet_food_pre;
+int HP_pet_food_post;
+int HP_pet_ai_sub_hard_lootsearch_pre;
+int HP_pet_ai_sub_hard_lootsearch_post;
+int HP_pet_menu_pre;
+int HP_pet_menu_post;
+int HP_pet_change_name_pre;
+int HP_pet_change_name_post;
+int HP_pet_change_name_ack_pre;
+int HP_pet_change_name_ack_post;
+int HP_pet_equipitem_pre;
+int HP_pet_equipitem_post;
+int HP_pet_randomwalk_pre;
+int HP_pet_randomwalk_post;
+int HP_pet_ai_sub_hard_pre;
+int HP_pet_ai_sub_hard_post;
+int HP_pet_ai_sub_foreachclient_pre;
+int HP_pet_ai_sub_foreachclient_post;
+int HP_pet_ai_hard_pre;
+int HP_pet_ai_hard_post;
+int HP_pet_delay_item_drop_pre;
+int HP_pet_delay_item_drop_post;
+int HP_pet_lootitem_drop_pre;
+int HP_pet_lootitem_drop_post;
+int HP_pet_skill_bonus_timer_pre;
+int HP_pet_skill_bonus_timer_post;
+int HP_pet_recovery_timer_pre;
+int HP_pet_recovery_timer_post;
+int HP_pet_heal_timer_pre;
+int HP_pet_heal_timer_post;
+int HP_pet_skill_support_timer_pre;
+int HP_pet_skill_support_timer_post;
+int HP_pet_read_db_pre;
+int HP_pet_read_db_post;
+int HP_quest_init_pre;
+int HP_quest_init_post;
+int HP_quest_reload_pre;
+int HP_quest_reload_post;
+int HP_quest_search_db_pre;
+int HP_quest_search_db_post;
+int HP_quest_pc_login_pre;
+int HP_quest_pc_login_post;
+int HP_quest_add_pre;
+int HP_quest_add_post;
+int HP_quest_change_pre;
+int HP_quest_change_post;
+int HP_quest_delete_pre;
+int HP_quest_delete_post;
+int HP_quest_update_objective_sub_pre;
+int HP_quest_update_objective_sub_post;
+int HP_quest_update_objective_pre;
+int HP_quest_update_objective_post;
+int HP_quest_update_status_pre;
+int HP_quest_update_status_post;
+int HP_quest_check_pre;
+int HP_quest_check_post;
+int HP_quest_read_db_pre;
+int HP_quest_read_db_post;
+int HP_script_init_pre;
+int HP_script_init_post;
+int HP_script_final_pre;
+int HP_script_final_post;
+int HP_script_reload_pre;
+int HP_script_reload_post;
+int HP_script_parse_pre;
+int HP_script_parse_post;
+int HP_script_parse_builtin_pre;
+int HP_script_parse_builtin_post;
+int HP_script_parse_subexpr_pre;
+int HP_script_parse_subexpr_post;
+int HP_script_skip_space_pre;
+int HP_script_skip_space_post;
+int HP_script_error_pre;
+int HP_script_error_post;
+int HP_script_warning_pre;
+int HP_script_warning_post;
+int HP_script_addScript_pre;
+int HP_script_addScript_post;
+int HP_script_conv_num_pre;
+int HP_script_conv_num_post;
+int HP_script_conv_str_pre;
+int HP_script_conv_str_post;
+int HP_script_rid2sd_pre;
+int HP_script_rid2sd_post;
+int HP_script_detach_rid_pre;
+int HP_script_detach_rid_post;
+int HP_script_push_val_pre;
+int HP_script_push_val_post;
+int HP_script_get_val_pre;
+int HP_script_get_val_post;
+int HP_script_get_val2_pre;
+int HP_script_get_val2_post;
+int HP_script_push_str_pre;
+int HP_script_push_str_post;
+int HP_script_push_copy_pre;
+int HP_script_push_copy_post;
+int HP_script_pop_stack_pre;
+int HP_script_pop_stack_post;
+int HP_script_set_constant_pre;
+int HP_script_set_constant_post;
+int HP_script_set_constant2_pre;
+int HP_script_set_constant2_post;
+int HP_script_set_constant_force_pre;
+int HP_script_set_constant_force_post;
+int HP_script_get_constant_pre;
+int HP_script_get_constant_post;
+int HP_script_label_add_pre;
+int HP_script_label_add_post;
+int HP_script_run_pre;
+int HP_script_run_post;
+int HP_script_run_main_pre;
+int HP_script_run_main_post;
+int HP_script_run_timer_pre;
+int HP_script_run_timer_post;
+int HP_script_set_var_pre;
+int HP_script_set_var_post;
+int HP_script_stop_instances_pre;
+int HP_script_stop_instances_post;
+int HP_script_free_code_pre;
+int HP_script_free_code_post;
+int HP_script_free_vars_pre;
+int HP_script_free_vars_post;
+int HP_script_alloc_state_pre;
+int HP_script_alloc_state_post;
+int HP_script_free_state_pre;
+int HP_script_free_state_post;
+int HP_script_run_autobonus_pre;
+int HP_script_run_autobonus_post;
+int HP_script_cleararray_pc_pre;
+int HP_script_cleararray_pc_post;
+int HP_script_setarray_pc_pre;
+int HP_script_setarray_pc_post;
+int HP_script_config_read_pre;
+int HP_script_config_read_post;
+int HP_script_add_str_pre;
+int HP_script_add_str_post;
+int HP_script_get_str_pre;
+int HP_script_get_str_post;
+int HP_script_search_str_pre;
+int HP_script_search_str_post;
+int HP_script_setd_sub_pre;
+int HP_script_setd_sub_post;
+int HP_script_attach_state_pre;
+int HP_script_attach_state_post;
+int HP_script_queue_pre;
+int HP_script_queue_post;
+int HP_script_queue_add_pre;
+int HP_script_queue_add_post;
+int HP_script_queue_del_pre;
+int HP_script_queue_del_post;
+int HP_script_queue_remove_pre;
+int HP_script_queue_remove_post;
+int HP_script_queue_create_pre;
+int HP_script_queue_create_post;
+int HP_script_queue_clear_pre;
+int HP_script_queue_clear_post;
+int HP_script_parse_curly_close_pre;
+int HP_script_parse_curly_close_post;
+int HP_script_parse_syntax_close_pre;
+int HP_script_parse_syntax_close_post;
+int HP_script_parse_syntax_close_sub_pre;
+int HP_script_parse_syntax_close_sub_post;
+int HP_script_parse_syntax_pre;
+int HP_script_parse_syntax_post;
+int HP_script_get_com_pre;
+int HP_script_get_com_post;
+int HP_script_get_num_pre;
+int HP_script_get_num_post;
+int HP_script_op2name_pre;
+int HP_script_op2name_post;
+int HP_script_reportsrc_pre;
+int HP_script_reportsrc_post;
+int HP_script_reportdata_pre;
+int HP_script_reportdata_post;
+int HP_script_reportfunc_pre;
+int HP_script_reportfunc_post;
+int HP_script_disp_error_message2_pre;
+int HP_script_disp_error_message2_post;
+int HP_script_disp_warning_message_pre;
+int HP_script_disp_warning_message_post;
+int HP_script_check_event_pre;
+int HP_script_check_event_post;
+int HP_script_calc_hash_pre;
+int HP_script_calc_hash_post;
+int HP_script_addb_pre;
+int HP_script_addb_post;
+int HP_script_addc_pre;
+int HP_script_addc_post;
+int HP_script_addi_pre;
+int HP_script_addi_post;
+int HP_script_addl_pre;
+int HP_script_addl_post;
+int HP_script_set_label_pre;
+int HP_script_set_label_post;
+int HP_script_skip_word_pre;
+int HP_script_skip_word_post;
+int HP_script_add_word_pre;
+int HP_script_add_word_post;
+int HP_script_parse_callfunc_pre;
+int HP_script_parse_callfunc_post;
+int HP_script_parse_nextline_pre;
+int HP_script_parse_nextline_post;
+int HP_script_parse_variable_pre;
+int HP_script_parse_variable_post;
+int HP_script_parse_simpleexpr_pre;
+int HP_script_parse_simpleexpr_post;
+int HP_script_parse_expr_pre;
+int HP_script_parse_expr_post;
+int HP_script_parse_line_pre;
+int HP_script_parse_line_post;
+int HP_script_read_constdb_pre;
+int HP_script_read_constdb_post;
+int HP_script_print_line_pre;
+int HP_script_print_line_post;
+int HP_script_errorwarning_sub_pre;
+int HP_script_errorwarning_sub_post;
+int HP_script_set_reg_pre;
+int HP_script_set_reg_post;
+int HP_script_stack_expand_pre;
+int HP_script_stack_expand_post;
+int HP_script_push_retinfo_pre;
+int HP_script_push_retinfo_post;
+int HP_script_pop_val_pre;
+int HP_script_pop_val_post;
+int HP_script_op_3_pre;
+int HP_script_op_3_post;
+int HP_script_op_2str_pre;
+int HP_script_op_2str_post;
+int HP_script_op_2num_pre;
+int HP_script_op_2num_post;
+int HP_script_op_2_pre;
+int HP_script_op_2_post;
+int HP_script_op_1_pre;
+int HP_script_op_1_post;
+int HP_script_check_buildin_argtype_pre;
+int HP_script_check_buildin_argtype_post;
+int HP_script_detach_state_pre;
+int HP_script_detach_state_post;
+int HP_script_db_free_code_sub_pre;
+int HP_script_db_free_code_sub_post;
+int HP_script_add_autobonus_pre;
+int HP_script_add_autobonus_post;
+int HP_script_menu_countoptions_pre;
+int HP_script_menu_countoptions_post;
+int HP_script_buildin_areawarp_sub_pre;
+int HP_script_buildin_areawarp_sub_post;
+int HP_script_buildin_areapercentheal_sub_pre;
+int HP_script_buildin_areapercentheal_sub_post;
+int HP_script_getarraysize_pre;
+int HP_script_getarraysize_post;
+int HP_script_buildin_delitem_delete_pre;
+int HP_script_buildin_delitem_delete_post;
+int HP_script_buildin_delitem_search_pre;
+int HP_script_buildin_delitem_search_post;
+int HP_script_buildin_killmonster_sub_strip_pre;
+int HP_script_buildin_killmonster_sub_strip_post;
+int HP_script_buildin_killmonster_sub_pre;
+int HP_script_buildin_killmonster_sub_post;
+int HP_script_buildin_killmonsterall_sub_strip_pre;
+int HP_script_buildin_killmonsterall_sub_strip_post;
+int HP_script_buildin_killmonsterall_sub_pre;
+int HP_script_buildin_killmonsterall_sub_post;
+int HP_script_buildin_announce_sub_pre;
+int HP_script_buildin_announce_sub_post;
+int HP_script_buildin_getareausers_sub_pre;
+int HP_script_buildin_getareausers_sub_post;
+int HP_script_buildin_getareadropitem_sub_pre;
+int HP_script_buildin_getareadropitem_sub_post;
+int HP_script_mapflag_pvp_sub_pre;
+int HP_script_mapflag_pvp_sub_post;
+int HP_script_buildin_pvpoff_sub_pre;
+int HP_script_buildin_pvpoff_sub_post;
+int HP_script_buildin_maprespawnguildid_sub_pc_pre;
+int HP_script_buildin_maprespawnguildid_sub_pc_post;
+int HP_script_buildin_maprespawnguildid_sub_mob_pre;
+int HP_script_buildin_maprespawnguildid_sub_mob_post;
+int HP_script_buildin_mobcount_sub_pre;
+int HP_script_buildin_mobcount_sub_post;
+int HP_script_playBGM_sub_pre;
+int HP_script_playBGM_sub_post;
+int HP_script_playBGM_foreachpc_sub_pre;
+int HP_script_playBGM_foreachpc_sub_post;
+int HP_script_soundeffect_sub_pre;
+int HP_script_soundeffect_sub_post;
+int HP_script_buildin_query_sql_sub_pre;
+int HP_script_buildin_query_sql_sub_post;
+int HP_script_axtoi_pre;
+int HP_script_axtoi_post;
+int HP_script_buildin_instance_warpall_sub_pre;
+int HP_script_buildin_instance_warpall_sub_post;
+int HP_script_buildin_mobuseskill_sub_pre;
+int HP_script_buildin_mobuseskill_sub_post;
+int HP_script_cleanfloor_sub_pre;
+int HP_script_cleanfloor_sub_post;
+int HP_script_run_func_pre;
+int HP_script_run_func_post;
+int HP_searchstore_open_pre;
+int HP_searchstore_open_post;
+int HP_searchstore_query_pre;
+int HP_searchstore_query_post;
+int HP_searchstore_querynext_pre;
+int HP_searchstore_querynext_post;
+int HP_searchstore_next_pre;
+int HP_searchstore_next_post;
+int HP_searchstore_clear_pre;
+int HP_searchstore_clear_post;
+int HP_searchstore_close_pre;
+int HP_searchstore_close_post;
+int HP_searchstore_click_pre;
+int HP_searchstore_click_post;
+int HP_searchstore_queryremote_pre;
+int HP_searchstore_queryremote_post;
+int HP_searchstore_clearremote_pre;
+int HP_searchstore_clearremote_post;
+int HP_searchstore_result_pre;
+int HP_searchstore_result_post;
+int HP_skill_init_pre;
+int HP_skill_init_post;
+int HP_skill_final_pre;
+int HP_skill_final_post;
+int HP_skill_reload_pre;
+int HP_skill_reload_post;
+int HP_skill_read_db_pre;
+int HP_skill_read_db_post;
+int HP_skill_get_index_pre;
+int HP_skill_get_index_post;
+int HP_skill_get_type_pre;
+int HP_skill_get_type_post;
+int HP_skill_get_hit_pre;
+int HP_skill_get_hit_post;
+int HP_skill_get_inf_pre;
+int HP_skill_get_inf_post;
+int HP_skill_get_ele_pre;
+int HP_skill_get_ele_post;
+int HP_skill_get_nk_pre;
+int HP_skill_get_nk_post;
+int HP_skill_get_max_pre;
+int HP_skill_get_max_post;
+int HP_skill_get_range_pre;
+int HP_skill_get_range_post;
+int HP_skill_get_range2_pre;
+int HP_skill_get_range2_post;
+int HP_skill_get_splash_pre;
+int HP_skill_get_splash_post;
+int HP_skill_get_hp_pre;
+int HP_skill_get_hp_post;
+int HP_skill_get_mhp_pre;
+int HP_skill_get_mhp_post;
+int HP_skill_get_sp_pre;
+int HP_skill_get_sp_post;
+int HP_skill_get_state_pre;
+int HP_skill_get_state_post;
+int HP_skill_get_spiritball_pre;
+int HP_skill_get_spiritball_post;
+int HP_skill_get_zeny_pre;
+int HP_skill_get_zeny_post;
+int HP_skill_get_num_pre;
+int HP_skill_get_num_post;
+int HP_skill_get_cast_pre;
+int HP_skill_get_cast_post;
+int HP_skill_get_delay_pre;
+int HP_skill_get_delay_post;
+int HP_skill_get_walkdelay_pre;
+int HP_skill_get_walkdelay_post;
+int HP_skill_get_time_pre;
+int HP_skill_get_time_post;
+int HP_skill_get_time2_pre;
+int HP_skill_get_time2_post;
+int HP_skill_get_castnodex_pre;
+int HP_skill_get_castnodex_post;
+int HP_skill_get_delaynodex_pre;
+int HP_skill_get_delaynodex_post;
+int HP_skill_get_castdef_pre;
+int HP_skill_get_castdef_post;
+int HP_skill_get_weapontype_pre;
+int HP_skill_get_weapontype_post;
+int HP_skill_get_ammotype_pre;
+int HP_skill_get_ammotype_post;
+int HP_skill_get_ammo_qty_pre;
+int HP_skill_get_ammo_qty_post;
+int HP_skill_get_unit_id_pre;
+int HP_skill_get_unit_id_post;
+int HP_skill_get_inf2_pre;
+int HP_skill_get_inf2_post;
+int HP_skill_get_castcancel_pre;
+int HP_skill_get_castcancel_post;
+int HP_skill_get_maxcount_pre;
+int HP_skill_get_maxcount_post;
+int HP_skill_get_blewcount_pre;
+int HP_skill_get_blewcount_post;
+int HP_skill_get_unit_flag_pre;
+int HP_skill_get_unit_flag_post;
+int HP_skill_get_unit_target_pre;
+int HP_skill_get_unit_target_post;
+int HP_skill_get_unit_interval_pre;
+int HP_skill_get_unit_interval_post;
+int HP_skill_get_unit_bl_target_pre;
+int HP_skill_get_unit_bl_target_post;
+int HP_skill_get_unit_layout_type_pre;
+int HP_skill_get_unit_layout_type_post;
+int HP_skill_get_unit_range_pre;
+int HP_skill_get_unit_range_post;
+int HP_skill_get_cooldown_pre;
+int HP_skill_get_cooldown_post;
+int HP_skill_tree_get_max_pre;
+int HP_skill_tree_get_max_post;
+int HP_skill_get_name_pre;
+int HP_skill_get_name_post;
+int HP_skill_get_desc_pre;
+int HP_skill_get_desc_post;
+int HP_skill_chk_pre;
+int HP_skill_chk_post;
+int HP_skill_get_casttype_pre;
+int HP_skill_get_casttype_post;
+int HP_skill_get_casttype2_pre;
+int HP_skill_get_casttype2_post;
+int HP_skill_name2id_pre;
+int HP_skill_name2id_post;
+int HP_skill_isammotype_pre;
+int HP_skill_isammotype_post;
+int HP_skill_castend_id_pre;
+int HP_skill_castend_id_post;
+int HP_skill_castend_pos_pre;
+int HP_skill_castend_pos_post;
+int HP_skill_castend_map_pre;
+int HP_skill_castend_map_post;
+int HP_skill_cleartimerskill_pre;
+int HP_skill_cleartimerskill_post;
+int HP_skill_addtimerskill_pre;
+int HP_skill_addtimerskill_post;
+int HP_skill_additional_effect_pre;
+int HP_skill_additional_effect_post;
+int HP_skill_counter_additional_effect_pre;
+int HP_skill_counter_additional_effect_post;
+int HP_skill_blown_pre;
+int HP_skill_blown_post;
+int HP_skill_break_equip_pre;
+int HP_skill_break_equip_post;
+int HP_skill_strip_equip_pre;
+int HP_skill_strip_equip_post;
+int HP_skill_id2group_pre;
+int HP_skill_id2group_post;
+int HP_skill_unitsetting_pre;
+int HP_skill_unitsetting_post;
+int HP_skill_initunit_pre;
+int HP_skill_initunit_post;
+int HP_skill_delunit_pre;
+int HP_skill_delunit_post;
+int HP_skill_init_unitgroup_pre;
+int HP_skill_init_unitgroup_post;
+int HP_skill_del_unitgroup_pre;
+int HP_skill_del_unitgroup_post;
+int HP_skill_clear_unitgroup_pre;
+int HP_skill_clear_unitgroup_post;
+int HP_skill_clear_group_pre;
+int HP_skill_clear_group_post;
+int HP_skill_unit_onplace_pre;
+int HP_skill_unit_onplace_post;
+int HP_skill_unit_ondamaged_pre;
+int HP_skill_unit_ondamaged_post;
+int HP_skill_cast_fix_pre;
+int HP_skill_cast_fix_post;
+int HP_skill_cast_fix_sc_pre;
+int HP_skill_cast_fix_sc_post;
+int HP_skill_vf_cast_fix_pre;
+int HP_skill_vf_cast_fix_post;
+int HP_skill_delay_fix_pre;
+int HP_skill_delay_fix_post;
+int HP_skill_check_condition_castbegin_pre;
+int HP_skill_check_condition_castbegin_post;
+int HP_skill_check_condition_castend_pre;
+int HP_skill_check_condition_castend_post;
+int HP_skill_consume_requirement_pre;
+int HP_skill_consume_requirement_post;
+int HP_skill_get_requirement_pre;
+int HP_skill_get_requirement_post;
+int HP_skill_check_pc_partner_pre;
+int HP_skill_check_pc_partner_post;
+int HP_skill_unit_move_pre;
+int HP_skill_unit_move_post;
+int HP_skill_unit_onleft_pre;
+int HP_skill_unit_onleft_post;
+int HP_skill_unit_onout_pre;
+int HP_skill_unit_onout_post;
+int HP_skill_unit_move_unit_group_pre;
+int HP_skill_unit_move_unit_group_post;
+int HP_skill_sit_pre;
+int HP_skill_sit_post;
+int HP_skill_brandishspear_pre;
+int HP_skill_brandishspear_post;
+int HP_skill_repairweapon_pre;
+int HP_skill_repairweapon_post;
+int HP_skill_identify_pre;
+int HP_skill_identify_post;
+int HP_skill_weaponrefine_pre;
+int HP_skill_weaponrefine_post;
+int HP_skill_autospell_pre;
+int HP_skill_autospell_post;
+int HP_skill_calc_heal_pre;
+int HP_skill_calc_heal_post;
+int HP_skill_check_cloaking_pre;
+int HP_skill_check_cloaking_post;
+int HP_skill_enchant_elemental_end_pre;
+int HP_skill_enchant_elemental_end_post;
+int HP_skill_not_ok_pre;
+int HP_skill_not_ok_post;
+int HP_skill_not_ok_hom_pre;
+int HP_skill_not_ok_hom_post;
+int HP_skill_not_ok_mercenary_pre;
+int HP_skill_not_ok_mercenary_post;
+int HP_skill_chastle_mob_changetarget_pre;
+int HP_skill_chastle_mob_changetarget_post;
+int HP_skill_can_produce_mix_pre;
+int HP_skill_can_produce_mix_post;
+int HP_skill_produce_mix_pre;
+int HP_skill_produce_mix_post;
+int HP_skill_arrow_create_pre;
+int HP_skill_arrow_create_post;
+int HP_skill_castend_nodamage_id_pre;
+int HP_skill_castend_nodamage_id_post;
+int HP_skill_castend_damage_id_pre;
+int HP_skill_castend_damage_id_post;
+int HP_skill_castend_pos2_pre;
+int HP_skill_castend_pos2_post;
+int HP_skill_blockpc_start_pre;
+int HP_skill_blockpc_start_post;
+int HP_skill_blockhomun_start_pre;
+int HP_skill_blockhomun_start_post;
+int HP_skill_blockmerc_start_pre;
+int HP_skill_blockmerc_start_post;
+int HP_skill_attack_pre;
+int HP_skill_attack_post;
+int HP_skill_attack_area_pre;
+int HP_skill_attack_area_post;
+int HP_skill_area_sub_pre;
+int HP_skill_area_sub_post;
+int HP_skill_area_sub_count_pre;
+int HP_skill_area_sub_count_post;
+int HP_skill_check_unit_range_pre;
+int HP_skill_check_unit_range_post;
+int HP_skill_check_unit_range_sub_pre;
+int HP_skill_check_unit_range_sub_post;
+int HP_skill_check_unit_range2_pre;
+int HP_skill_check_unit_range2_post;
+int HP_skill_check_unit_range2_sub_pre;
+int HP_skill_check_unit_range2_sub_post;
+int HP_skill_toggle_magicpower_pre;
+int HP_skill_toggle_magicpower_post;
+int HP_skill_magic_reflect_pre;
+int HP_skill_magic_reflect_post;
+int HP_skill_onskillusage_pre;
+int HP_skill_onskillusage_post;
+int HP_skill_cell_overlap_pre;
+int HP_skill_cell_overlap_post;
+int HP_skill_timerskill_pre;
+int HP_skill_timerskill_post;
+int HP_skill_trap_splash_pre;
+int HP_skill_trap_splash_post;
+int HP_skill_check_condition_mercenary_pre;
+int HP_skill_check_condition_mercenary_post;
+int HP_skill_locate_element_field_pre;
+int HP_skill_locate_element_field_post;
+int HP_skill_graffitiremover_pre;
+int HP_skill_graffitiremover_post;
+int HP_skill_activate_reverberation_pre;
+int HP_skill_activate_reverberation_post;
+int HP_skill_dance_overlap_sub_pre;
+int HP_skill_dance_overlap_sub_post;
+int HP_skill_dance_overlap_pre;
+int HP_skill_dance_overlap_post;
+int HP_skill_get_unit_layout_pre;
+int HP_skill_get_unit_layout_post;
+int HP_skill_frostjoke_scream_pre;
+int HP_skill_frostjoke_scream_post;
+int HP_skill_greed_pre;
+int HP_skill_greed_post;
+int HP_skill_destroy_trap_pre;
+int HP_skill_destroy_trap_post;
+int HP_skill_icewall_block_pre;
+int HP_skill_icewall_block_post;
+int HP_skill_unitgrouptickset_search_pre;
+int HP_skill_unitgrouptickset_search_post;
+int HP_skill_dance_switch_pre;
+int HP_skill_dance_switch_post;
+int HP_skill_check_condition_char_sub_pre;
+int HP_skill_check_condition_char_sub_post;
+int HP_skill_check_condition_mob_master_sub_pre;
+int HP_skill_check_condition_mob_master_sub_post;
+int HP_skill_brandishspear_first_pre;
+int HP_skill_brandishspear_first_post;
+int HP_skill_brandishspear_dir_pre;
+int HP_skill_brandishspear_dir_post;
+int HP_skill_get_fixed_cast_pre;
+int HP_skill_get_fixed_cast_post;
+int HP_skill_sit_count_pre;
+int HP_skill_sit_count_post;
+int HP_skill_sit_in_pre;
+int HP_skill_sit_in_post;
+int HP_skill_sit_out_pre;
+int HP_skill_sit_out_post;
+int HP_skill_unitsetmapcell_pre;
+int HP_skill_unitsetmapcell_post;
+int HP_skill_unit_onplace_timer_pre;
+int HP_skill_unit_onplace_timer_post;
+int HP_skill_unit_effect_pre;
+int HP_skill_unit_effect_post;
+int HP_skill_unit_timer_sub_onplace_pre;
+int HP_skill_unit_timer_sub_onplace_post;
+int HP_skill_unit_move_sub_pre;
+int HP_skill_unit_move_sub_post;
+int HP_skill_blockpc_end_pre;
+int HP_skill_blockpc_end_post;
+int HP_skill_blockhomun_end_pre;
+int HP_skill_blockhomun_end_post;
+int HP_skill_blockmerc_end_pre;
+int HP_skill_blockmerc_end_post;
+int HP_skill_split_atoi_pre;
+int HP_skill_split_atoi_post;
+int HP_skill_unit_timer_pre;
+int HP_skill_unit_timer_post;
+int HP_skill_unit_timer_sub_pre;
+int HP_skill_unit_timer_sub_post;
+int HP_skill_init_unit_layout_pre;
+int HP_skill_init_unit_layout_post;
+int HP_skill_parse_row_skilldb_pre;
+int HP_skill_parse_row_skilldb_post;
+int HP_skill_parse_row_requiredb_pre;
+int HP_skill_parse_row_requiredb_post;
+int HP_skill_parse_row_castdb_pre;
+int HP_skill_parse_row_castdb_post;
+int HP_skill_parse_row_castnodexdb_pre;
+int HP_skill_parse_row_castnodexdb_post;
+int HP_skill_parse_row_unitdb_pre;
+int HP_skill_parse_row_unitdb_post;
+int HP_skill_parse_row_producedb_pre;
+int HP_skill_parse_row_producedb_post;
+int HP_skill_parse_row_createarrowdb_pre;
+int HP_skill_parse_row_createarrowdb_post;
+int HP_skill_parse_row_abradb_pre;
+int HP_skill_parse_row_abradb_post;
+int HP_skill_parse_row_spellbookdb_pre;
+int HP_skill_parse_row_spellbookdb_post;
+int HP_skill_parse_row_magicmushroomdb_pre;
+int HP_skill_parse_row_magicmushroomdb_post;
+int HP_skill_parse_row_reproducedb_pre;
+int HP_skill_parse_row_reproducedb_post;
+int HP_skill_parse_row_improvisedb_pre;
+int HP_skill_parse_row_improvisedb_post;
+int HP_skill_parse_row_changematerialdb_pre;
+int HP_skill_parse_row_changematerialdb_post;
+int HP_skill_usave_add_pre;
+int HP_skill_usave_add_post;
+int HP_skill_usave_trigger_pre;
+int HP_skill_usave_trigger_post;
+int HP_skill_cooldown_load_pre;
+int HP_skill_cooldown_load_post;
+int HP_skill_spellbook_pre;
+int HP_skill_spellbook_post;
+int HP_skill_block_check_pre;
+int HP_skill_block_check_post;
+int HP_skill_detonator_pre;
+int HP_skill_detonator_post;
+int HP_skill_check_camouflage_pre;
+int HP_skill_check_camouflage_post;
+int HP_skill_magicdecoy_pre;
+int HP_skill_magicdecoy_post;
+int HP_skill_poisoningweapon_pre;
+int HP_skill_poisoningweapon_post;
+int HP_skill_select_menu_pre;
+int HP_skill_select_menu_post;
+int HP_skill_elementalanalysis_pre;
+int HP_skill_elementalanalysis_post;
+int HP_skill_changematerial_pre;
+int HP_skill_changematerial_post;
+int HP_skill_get_elemental_type_pre;
+int HP_skill_get_elemental_type_post;
+int HP_skill_cooldown_save_pre;
+int HP_skill_cooldown_save_post;
+int HP_skill_maelstrom_suction_pre;
+int HP_skill_maelstrom_suction_post;
+int HP_skill_get_new_group_id_pre;
+int HP_skill_get_new_group_id_post;
+int HP_status_init_pre;
+int HP_status_init_post;
+int HP_status_final_pre;
+int HP_status_final_post;
+int HP_status_get_refine_chance_pre;
+int HP_status_get_refine_chance_post;
+int HP_status_skill2sc_pre;
+int HP_status_skill2sc_post;
+int HP_status_sc2skill_pre;
+int HP_status_sc2skill_post;
+int HP_status_sc2scb_flag_pre;
+int HP_status_sc2scb_flag_post;
+int HP_status_type2relevant_bl_types_pre;
+int HP_status_type2relevant_bl_types_post;
+int HP_status_get_sc_type_pre;
+int HP_status_get_sc_type_post;
+int HP_status_damage_pre;
+int HP_status_damage_post;
+int HP_status_charge_pre;
+int HP_status_charge_post;
+int HP_status_percent_change_pre;
+int HP_status_percent_change_post;
+int HP_status_set_hp_pre;
+int HP_status_set_hp_post;
+int HP_status_set_sp_pre;
+int HP_status_set_sp_post;
+int HP_status_heal_pre;
+int HP_status_heal_post;
+int HP_status_revive_pre;
+int HP_status_revive_post;
+int HP_status_get_regen_data_pre;
+int HP_status_get_regen_data_post;
+int HP_status_get_status_data_pre;
+int HP_status_get_status_data_post;
+int HP_status_get_base_status_pre;
+int HP_status_get_base_status_post;
+int HP_status_get_name_pre;
+int HP_status_get_name_post;
+int HP_status_get_class_pre;
+int HP_status_get_class_post;
+int HP_status_get_lv_pre;
+int HP_status_get_lv_post;
+int HP_status_get_def_pre;
+int HP_status_get_def_post;
+int HP_status_get_speed_pre;
+int HP_status_get_speed_post;
+int HP_status_calc_attack_element_pre;
+int HP_status_calc_attack_element_post;
+int HP_status_get_party_id_pre;
+int HP_status_get_party_id_post;
+int HP_status_get_guild_id_pre;
+int HP_status_get_guild_id_post;
+int HP_status_get_emblem_id_pre;
+int HP_status_get_emblem_id_post;
+int HP_status_get_mexp_pre;
+int HP_status_get_mexp_post;
+int HP_status_get_race2_pre;
+int HP_status_get_race2_post;
+int HP_status_get_viewdata_pre;
+int HP_status_get_viewdata_post;
+int HP_status_set_viewdata_pre;
+int HP_status_set_viewdata_post;
+int HP_status_change_init_pre;
+int HP_status_change_init_post;
+int HP_status_get_sc_pre;
+int HP_status_get_sc_post;
+int HP_status_isdead_pre;
+int HP_status_isdead_post;
+int HP_status_isimmune_pre;
+int HP_status_isimmune_post;
+int HP_status_get_sc_def_pre;
+int HP_status_get_sc_def_post;
+int HP_status_change_start_pre;
+int HP_status_change_start_post;
+int HP_status_change_end__pre;
+int HP_status_change_end__post;
+int HP_status_kaahi_heal_timer_pre;
+int HP_status_kaahi_heal_timer_post;
+int HP_status_change_timer_pre;
+int HP_status_change_timer_post;
+int HP_status_change_timer_sub_pre;
+int HP_status_change_timer_sub_post;
+int HP_status_change_clear_pre;
+int HP_status_change_clear_post;
+int HP_status_change_clear_buffs_pre;
+int HP_status_change_clear_buffs_post;
+int HP_status_calc_bl__pre;
+int HP_status_calc_bl__post;
+int HP_status_calc_mob__pre;
+int HP_status_calc_mob__post;
+int HP_status_calc_pet__pre;
+int HP_status_calc_pet__post;
+int HP_status_calc_pc__pre;
+int HP_status_calc_pc__post;
+int HP_status_calc_homunculus__pre;
+int HP_status_calc_homunculus__post;
+int HP_status_calc_mercenary__pre;
+int HP_status_calc_mercenary__post;
+int HP_status_calc_elemental__pre;
+int HP_status_calc_elemental__post;
+int HP_status_calc_misc_pre;
+int HP_status_calc_misc_post;
+int HP_status_calc_regen_pre;
+int HP_status_calc_regen_post;
+int HP_status_calc_regen_rate_pre;
+int HP_status_calc_regen_rate_post;
+int HP_status_check_skilluse_pre;
+int HP_status_check_skilluse_post;
+int HP_status_check_visibility_pre;
+int HP_status_check_visibility_post;
+int HP_status_change_spread_pre;
+int HP_status_change_spread_post;
+int HP_status_calc_def_pre;
+int HP_status_calc_def_post;
+int HP_status_calc_def2_pre;
+int HP_status_calc_def2_post;
+int HP_status_calc_mdef_pre;
+int HP_status_calc_mdef_post;
+int HP_status_calc_mdef2_pre;
+int HP_status_calc_mdef2_post;
+int HP_status_calc_batk_pre;
+int HP_status_calc_batk_post;
+int HP_status_get_total_mdef_pre;
+int HP_status_get_total_mdef_post;
+int HP_status_get_total_def_pre;
+int HP_status_get_total_def_post;
+int HP_status_get_matk_pre;
+int HP_status_get_matk_post;
+int HP_status_readdb_pre;
+int HP_status_readdb_post;
+int HP_status_initChangeTables_pre;
+int HP_status_initChangeTables_post;
+int HP_status_initDummyData_pre;
+int HP_status_initDummyData_post;
+int HP_status_base_amotion_pc_pre;
+int HP_status_base_amotion_pc_post;
+int HP_status_base_atk_pre;
+int HP_status_base_atk_post;
+int HP_status_calc_sigma_pre;
+int HP_status_calc_sigma_post;
+int HP_status_base_pc_maxhp_pre;
+int HP_status_base_pc_maxhp_post;
+int HP_status_base_pc_maxsp_pre;
+int HP_status_base_pc_maxsp_post;
+int HP_status_calc_npc__pre;
+int HP_status_calc_npc__post;
+int HP_status_calc_str_pre;
+int HP_status_calc_str_post;
+int HP_status_calc_agi_pre;
+int HP_status_calc_agi_post;
+int HP_status_calc_vit_pre;
+int HP_status_calc_vit_post;
+int HP_status_calc_int_pre;
+int HP_status_calc_int_post;
+int HP_status_calc_dex_pre;
+int HP_status_calc_dex_post;
+int HP_status_calc_luk_pre;
+int HP_status_calc_luk_post;
+int HP_status_calc_watk_pre;
+int HP_status_calc_watk_post;
+int HP_status_calc_matk_pre;
+int HP_status_calc_matk_post;
+int HP_status_calc_hit_pre;
+int HP_status_calc_hit_post;
+int HP_status_calc_critical_pre;
+int HP_status_calc_critical_post;
+int HP_status_calc_flee_pre;
+int HP_status_calc_flee_post;
+int HP_status_calc_flee2_pre;
+int HP_status_calc_flee2_post;
+int HP_status_calc_speed_pre;
+int HP_status_calc_speed_post;
+int HP_status_calc_aspd_rate_pre;
+int HP_status_calc_aspd_rate_post;
+int HP_status_calc_dmotion_pre;
+int HP_status_calc_dmotion_post;
+int HP_status_calc_fix_aspd_pre;
+int HP_status_calc_fix_aspd_post;
+int HP_status_calc_maxhp_pre;
+int HP_status_calc_maxhp_post;
+int HP_status_calc_maxsp_pre;
+int HP_status_calc_maxsp_post;
+int HP_status_calc_element_pre;
+int HP_status_calc_element_post;
+int HP_status_calc_element_lv_pre;
+int HP_status_calc_element_lv_post;
+int HP_status_calc_mode_pre;
+int HP_status_calc_mode_post;
+int HP_status_calc_bl_main_pre;
+int HP_status_calc_bl_main_post;
+int HP_status_display_add_pre;
+int HP_status_display_add_post;
+int HP_status_display_remove_pre;
+int HP_status_display_remove_post;
+int HP_status_natural_heal_pre;
+int HP_status_natural_heal_post;
+int HP_status_natural_heal_timer_pre;
+int HP_status_natural_heal_timer_post;
+int HP_status_readdb_job1_pre;
+int HP_status_readdb_job1_post;
+int HP_status_readdb_job2_pre;
+int HP_status_readdb_job2_post;
+int HP_status_readdb_sizefix_pre;
+int HP_status_readdb_sizefix_post;
+int HP_status_readdb_refine_pre;
+int HP_status_readdb_refine_post;
+int HP_status_readdb_scconfig_pre;
+int HP_status_readdb_scconfig_post;
+int HP_storage_reconnect_pre;
+int HP_storage_reconnect_post;
+int HP_storage_delitem_pre;
+int HP_storage_delitem_post;
+int HP_storage_open_pre;
+int HP_storage_open_post;
+int HP_storage_add_pre;
+int HP_storage_add_post;
+int HP_storage_get_pre;
+int HP_storage_get_post;
+int HP_storage_additem_pre;
+int HP_storage_additem_post;
+int HP_storage_addfromcart_pre;
+int HP_storage_addfromcart_post;
+int HP_storage_gettocart_pre;
+int HP_storage_gettocart_post;
+int HP_storage_close_pre;
+int HP_storage_close_post;
+int HP_storage_pc_quit_pre;
+int HP_storage_pc_quit_post;
+int HP_storage_comp_item_pre;
+int HP_storage_comp_item_post;
+int HP_storage_sortitem_pre;
+int HP_storage_sortitem_post;
+int HP_storage_reconnect_sub_pre;
+int HP_storage_reconnect_sub_post;
+int HP_trade_request_pre;
+int HP_trade_request_post;
+int HP_trade_ack_pre;
+int HP_trade_ack_post;
+int HP_trade_check_impossible_pre;
+int HP_trade_check_impossible_post;
+int HP_trade_check_pre;
+int HP_trade_check_post;
+int HP_trade_additem_pre;
+int HP_trade_additem_post;
+int HP_trade_addzeny_pre;
+int HP_trade_addzeny_post;
+int HP_trade_ok_pre;
+int HP_trade_ok_post;
+int HP_trade_cancel_pre;
+int HP_trade_cancel_post;
+int HP_trade_commit_pre;
+int HP_trade_commit_post;
+int HP_unit_init_pre;
+int HP_unit_init_post;
+int HP_unit_final_pre;
+int HP_unit_final_post;
+int HP_unit_bl2ud_pre;
+int HP_unit_bl2ud_post;
+int HP_unit_bl2ud2_pre;
+int HP_unit_bl2ud2_post;
+int HP_unit_attack_timer_pre;
+int HP_unit_attack_timer_post;
+int HP_unit_walktoxy_timer_pre;
+int HP_unit_walktoxy_timer_post;
+int HP_unit_walktoxy_sub_pre;
+int HP_unit_walktoxy_sub_post;
+int HP_unit_delay_walktoxy_timer_pre;
+int HP_unit_delay_walktoxy_timer_post;
+int HP_unit_walktoxy_pre;
+int HP_unit_walktoxy_post;
+int HP_unit_walktobl_sub_pre;
+int HP_unit_walktobl_sub_post;
+int HP_unit_walktobl_pre;
+int HP_unit_walktobl_post;
+int HP_unit_run_pre;
+int HP_unit_run_post;
+int HP_unit_wugdash_pre;
+int HP_unit_wugdash_post;
+int HP_unit_escape_pre;
+int HP_unit_escape_post;
+int HP_unit_movepos_pre;
+int HP_unit_movepos_post;
+int HP_unit_setdir_pre;
+int HP_unit_setdir_post;
+int HP_unit_getdir_pre;
+int HP_unit_getdir_post;
+int HP_unit_blown_pre;
+int HP_unit_blown_post;
+int HP_unit_warp_pre;
+int HP_unit_warp_post;
+int HP_unit_stop_walking_pre;
+int HP_unit_stop_walking_post;
+int HP_unit_skilluse_id_pre;
+int HP_unit_skilluse_id_post;
+int HP_unit_is_walking_pre;
+int HP_unit_is_walking_post;
+int HP_unit_can_move_pre;
+int HP_unit_can_move_post;
+int HP_unit_resume_running_pre;
+int HP_unit_resume_running_post;
+int HP_unit_set_walkdelay_pre;
+int HP_unit_set_walkdelay_post;
+int HP_unit_skilluse_id2_pre;
+int HP_unit_skilluse_id2_post;
+int HP_unit_skilluse_pos_pre;
+int HP_unit_skilluse_pos_post;
+int HP_unit_skilluse_pos2_pre;
+int HP_unit_skilluse_pos2_post;
+int HP_unit_set_target_pre;
+int HP_unit_set_target_post;
+int HP_unit_stop_attack_pre;
+int HP_unit_stop_attack_post;
+int HP_unit_unattackable_pre;
+int HP_unit_unattackable_post;
+int HP_unit_attack_pre;
+int HP_unit_attack_post;
+int HP_unit_cancel_combo_pre;
+int HP_unit_cancel_combo_post;
+int HP_unit_can_reach_pos_pre;
+int HP_unit_can_reach_pos_post;
+int HP_unit_can_reach_bl_pre;
+int HP_unit_can_reach_bl_post;
+int HP_unit_calc_pos_pre;
+int HP_unit_calc_pos_post;
+int HP_unit_attack_timer_sub_pre;
+int HP_unit_attack_timer_sub_post;
+int HP_unit_skillcastcancel_pre;
+int HP_unit_skillcastcancel_post;
+int HP_unit_dataset_pre;
+int HP_unit_dataset_post;
+int HP_unit_counttargeted_pre;
+int HP_unit_counttargeted_post;
+int HP_unit_fixdamage_pre;
+int HP_unit_fixdamage_post;
+int HP_unit_changeviewsize_pre;
+int HP_unit_changeviewsize_post;
+int HP_unit_remove_map_pre;
+int HP_unit_remove_map_post;
+int HP_unit_remove_map_pc_pre;
+int HP_unit_remove_map_pc_post;
+int HP_unit_free_pc_pre;
+int HP_unit_free_pc_post;
+int HP_unit_free_pre;
+int HP_unit_free_post;
+int HP_vending_init_pre;
+int HP_vending_init_post;
+int HP_vending_final_pre;
+int HP_vending_final_post;
+int HP_vending_close_pre;
+int HP_vending_close_post;
+int HP_vending_open_pre;
+int HP_vending_open_post;
+int HP_vending_list_pre;
+int HP_vending_list_post;
+int HP_vending_purchase_pre;
+int HP_vending_purchase_post;
+int HP_vending_search_pre;
+int HP_vending_search_post;
+int HP_vending_searchall_pre;
+int HP_vending_searchall_post;
+} count;
+struct {
+struct atcommand_interface atcommand;
+struct battle_interface battle;
+struct battleground_interface bg;
+struct buyingstore_interface buyingstore;
+struct chat_interface chat;
+struct chrif_interface chrif;
+struct clif_interface clif;
+struct duel_interface duel;
+struct elemental_interface elemental;
+struct guild_interface guild;
+struct guild_storage_interface gstorage;
+struct homunculus_interface homun;
+struct instance_interface instance;
+struct intif_interface intif;
+struct irc_bot_interface ircbot;
+struct itemdb_interface itemdb;
+struct log_interface logs;
+struct mail_interface mail;
+struct map_interface map;
+struct mapit_interface mapit;
+struct mapreg_interface mapreg;
+struct mercenary_interface mercenary;
+struct mob_interface mob;
+struct npc_interface npc;
+struct party_interface party;
+struct path_interface path;
+struct pc_interface pc;
+struct pet_interface pet;
+struct quest_interface quest;
+struct script_interface script;
+struct searchstore_interface searchstore;
+struct skill_interface skill;
+struct status_interface status;
+struct storage_interface storage;
+struct trade_interface trade;
+struct unit_interface unit;
+struct vending_interface vending;
+} source;
diff --git a/src/plugins/HPMHooking/HPMHooking.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking.HookingPoints.inc
new file mode 100644
index 000000000..69f6e287a
--- /dev/null
+++ b/src/plugins/HPMHooking/HPMHooking.HookingPoints.inc
@@ -0,0 +1,2445 @@
+struct HookingPointData HookingPoints[] = {
+/* atcommand */
+{ HP_POP(atcommand->init), HP_POP2(HP_atcommand_init), 0 },
+{ HP_POP(atcommand->final), HP_POP2(HP_atcommand_final), 2 },
+{ HP_POP(atcommand->parse), HP_POP2(HP_atcommand_parse), 4 },
+{ HP_POP(atcommand->create), HP_POP2(HP_atcommand_create), 6 },
+{ HP_POP(atcommand->can_use), HP_POP2(HP_atcommand_can_use), 8 },
+{ HP_POP(atcommand->can_use2), HP_POP2(HP_atcommand_can_use2), 10 },
+{ HP_POP(atcommand->load_groups), HP_POP2(HP_atcommand_load_groups), 12 },
+{ HP_POP(atcommand->exists), HP_POP2(HP_atcommand_exists), 14 },
+{ HP_POP(atcommand->msg_read), HP_POP2(HP_atcommand_msg_read), 16 },
+{ HP_POP(atcommand->final_msg), HP_POP2(HP_atcommand_final_msg), 18 },
+{ HP_POP(atcommand->get_bind_byname), HP_POP2(HP_atcommand_get_bind_byname), 20 },
+{ HP_POP(atcommand->get_info_byname), HP_POP2(HP_atcommand_get_info_byname), 22 },
+{ HP_POP(atcommand->check_alias), HP_POP2(HP_atcommand_check_alias), 24 },
+{ HP_POP(atcommand->get_suggestions), HP_POP2(HP_atcommand_get_suggestions), 26 },
+{ HP_POP(atcommand->config_read), HP_POP2(HP_atcommand_config_read), 28 },
+{ HP_POP(atcommand->stopattack), HP_POP2(HP_atcommand_stopattack), 30 },
+{ HP_POP(atcommand->pvpoff_sub), HP_POP2(HP_atcommand_pvpoff_sub), 32 },
+{ HP_POP(atcommand->pvpon_sub), HP_POP2(HP_atcommand_pvpon_sub), 34 },
+{ HP_POP(atcommand->atkillmonster_sub), HP_POP2(HP_atcommand_atkillmonster_sub), 36 },
+{ HP_POP(atcommand->raise_sub), HP_POP2(HP_atcommand_raise_sub), 38 },
+{ HP_POP(atcommand->get_jail_time), HP_POP2(HP_atcommand_get_jail_time), 40 },
+{ HP_POP(atcommand->cleanfloor_sub), HP_POP2(HP_atcommand_cleanfloor_sub), 42 },
+{ HP_POP(atcommand->mutearea_sub), HP_POP2(HP_atcommand_mutearea_sub), 44 },
+{ HP_POP(atcommand->commands_sub), HP_POP2(HP_atcommand_commands_sub), 46 },
+{ HP_POP(atcommand->cmd_db_clear), HP_POP2(HP_atcommand_cmd_db_clear), 48 },
+{ HP_POP(atcommand->cmd_db_clear_sub), HP_POP2(HP_atcommand_cmd_db_clear_sub), 50 },
+{ HP_POP(atcommand->doload), HP_POP2(HP_atcommand_doload), 52 },
+{ HP_POP(atcommand->base_commands), HP_POP2(HP_atcommand_base_commands), 54 },
+/* battle */
+{ HP_POP(battle->init), HP_POP2(HP_battle_init), 56 },
+{ HP_POP(battle->final), HP_POP2(HP_battle_final), 58 },
+{ HP_POP(battle->calc_attack), HP_POP2(HP_battle_calc_attack), 60 },
+{ HP_POP(battle->calc_damage), HP_POP2(HP_battle_calc_damage), 62 },
+{ HP_POP(battle->calc_gvg_damage), HP_POP2(HP_battle_calc_gvg_damage), 64 },
+{ HP_POP(battle->calc_bg_damage), HP_POP2(HP_battle_calc_bg_damage), 66 },
+{ HP_POP(battle->weapon_attack), HP_POP2(HP_battle_weapon_attack), 68 },
+{ HP_POP(battle->calc_weapon_attack), HP_POP2(HP_battle_calc_weapon_attack), 70 },
+{ HP_POP(battle->delay_damage), HP_POP2(HP_battle_delay_damage), 72 },
+{ HP_POP(battle->drain), HP_POP2(HP_battle_drain), 74 },
+{ HP_POP(battle->calc_return_damage), HP_POP2(HP_battle_calc_return_damage), 76 },
+{ HP_POP(battle->attr_ratio), HP_POP2(HP_battle_attr_ratio), 78 },
+{ HP_POP(battle->attr_fix), HP_POP2(HP_battle_attr_fix), 80 },
+{ HP_POP(battle->calc_cardfix), HP_POP2(HP_battle_calc_cardfix), 82 },
+{ HP_POP(battle->calc_elefix), HP_POP2(HP_battle_calc_elefix), 84 },
+{ HP_POP(battle->calc_masteryfix), HP_POP2(HP_battle_calc_masteryfix), 86 },
+{ HP_POP(battle->calc_skillratio), HP_POP2(HP_battle_calc_skillratio), 88 },
+{ HP_POP(battle->calc_sizefix), HP_POP2(HP_battle_calc_sizefix), 90 },
+{ HP_POP(battle->calc_weapon_damage), HP_POP2(HP_battle_calc_weapon_damage), 92 },
+{ HP_POP(battle->calc_defense), HP_POP2(HP_battle_calc_defense), 94 },
+{ HP_POP(battle->get_master), HP_POP2(HP_battle_get_master), 96 },
+{ HP_POP(battle->get_targeted), HP_POP2(HP_battle_get_targeted), 98 },
+{ HP_POP(battle->get_enemy), HP_POP2(HP_battle_get_enemy), 100 },
+{ HP_POP(battle->get_target), HP_POP2(HP_battle_get_target), 102 },
+{ HP_POP(battle->get_current_skill), HP_POP2(HP_battle_get_current_skill), 104 },
+{ HP_POP(battle->check_undead), HP_POP2(HP_battle_check_undead), 106 },
+{ HP_POP(battle->check_target), HP_POP2(HP_battle_check_target), 108 },
+{ HP_POP(battle->check_range), HP_POP2(HP_battle_check_range), 110 },
+{ HP_POP(battle->consume_ammo), HP_POP2(HP_battle_consume_ammo), 112 },
+{ HP_POP(battle->get_targeted_sub), HP_POP2(HP_battle_get_targeted_sub), 114 },
+{ HP_POP(battle->get_enemy_sub), HP_POP2(HP_battle_get_enemy_sub), 116 },
+{ HP_POP(battle->get_enemy_area_sub), HP_POP2(HP_battle_get_enemy_area_sub), 118 },
+{ HP_POP(battle->delay_damage_sub), HP_POP2(HP_battle_delay_damage_sub), 120 },
+{ HP_POP(battle->blewcount_bonus), HP_POP2(HP_battle_blewcount_bonus), 122 },
+{ HP_POP(battle->range_type), HP_POP2(HP_battle_range_type), 124 },
+{ HP_POP(battle->calc_base_damage), HP_POP2(HP_battle_calc_base_damage), 126 },
+{ HP_POP(battle->calc_base_damage2), HP_POP2(HP_battle_calc_base_damage2), 128 },
+{ HP_POP(battle->calc_misc_attack), HP_POP2(HP_battle_calc_misc_attack), 130 },
+{ HP_POP(battle->calc_magic_attack), HP_POP2(HP_battle_calc_magic_attack), 132 },
+{ HP_POP(battle->adjust_skill_damage), HP_POP2(HP_battle_adjust_skill_damage), 134 },
+{ HP_POP(battle->add_mastery), HP_POP2(HP_battle_add_mastery), 136 },
+{ HP_POP(battle->calc_drain), HP_POP2(HP_battle_calc_drain), 138 },
+{ HP_POP(battle->config_read), HP_POP2(HP_battle_config_read), 140 },
+{ HP_POP(battle->config_set_defaults), HP_POP2(HP_battle_config_set_defaults), 142 },
+{ HP_POP(battle->config_set_value), HP_POP2(HP_battle_config_set_value), 144 },
+{ HP_POP(battle->config_get_value), HP_POP2(HP_battle_config_get_value), 146 },
+{ HP_POP(battle->config_adjust), HP_POP2(HP_battle_config_adjust), 148 },
+{ HP_POP(battle->get_enemy_area), HP_POP2(HP_battle_get_enemy_area), 150 },
+{ HP_POP(battle->damage_area), HP_POP2(HP_battle_damage_area), 152 },
+/* bg */
+{ HP_POP(bg->init), HP_POP2(HP_bg_init), 154 },
+{ HP_POP(bg->final), HP_POP2(HP_bg_final), 156 },
+{ HP_POP(bg->name2arena), HP_POP2(HP_bg_name2arena), 158 },
+{ HP_POP(bg->queue_add), HP_POP2(HP_bg_queue_add), 160 },
+{ HP_POP(bg->can_queue), HP_POP2(HP_bg_can_queue), 162 },
+{ HP_POP(bg->id2pos), HP_POP2(HP_bg_id2pos), 164 },
+{ HP_POP(bg->queue_pc_cleanup), HP_POP2(HP_bg_queue_pc_cleanup), 166 },
+{ HP_POP(bg->begin), HP_POP2(HP_bg_begin), 168 },
+{ HP_POP(bg->begin_timer), HP_POP2(HP_bg_begin_timer), 170 },
+{ HP_POP(bg->queue_pregame), HP_POP2(HP_bg_queue_pregame), 172 },
+{ HP_POP(bg->fillup_timer), HP_POP2(HP_bg_fillup_timer), 174 },
+{ HP_POP(bg->queue_ready_ack), HP_POP2(HP_bg_queue_ready_ack), 176 },
+{ HP_POP(bg->match_over), HP_POP2(HP_bg_match_over), 178 },
+{ HP_POP(bg->queue_check), HP_POP2(HP_bg_queue_check), 180 },
+{ HP_POP(bg->team_search), HP_POP2(HP_bg_team_search), 182 },
+{ HP_POP(bg->getavailablesd), HP_POP2(HP_bg_getavailablesd), 184 },
+{ HP_POP(bg->team_delete), HP_POP2(HP_bg_team_delete), 186 },
+{ HP_POP(bg->team_warp), HP_POP2(HP_bg_team_warp), 188 },
+{ HP_POP(bg->send_dot_remove), HP_POP2(HP_bg_send_dot_remove), 190 },
+{ HP_POP(bg->team_join), HP_POP2(HP_bg_team_join), 192 },
+{ HP_POP(bg->team_leave), HP_POP2(HP_bg_team_leave), 194 },
+{ HP_POP(bg->member_respawn), HP_POP2(HP_bg_member_respawn), 196 },
+{ HP_POP(bg->create), HP_POP2(HP_bg_create), 198 },
+{ HP_POP(bg->team_get_id), HP_POP2(HP_bg_team_get_id), 200 },
+{ HP_POP(bg->send_message), HP_POP2(HP_bg_send_message), 202 },
+{ HP_POP(bg->send_xy_timer_sub), HP_POP2(HP_bg_send_xy_timer_sub), 204 },
+{ HP_POP(bg->send_xy_timer), HP_POP2(HP_bg_send_xy_timer), 206 },
+{ HP_POP(bg->config_read), HP_POP2(HP_bg_config_read), 208 },
+/* buyingstore */
+{ HP_POP(buyingstore->setup), HP_POP2(HP_buyingstore_setup), 210 },
+{ HP_POP(buyingstore->create), HP_POP2(HP_buyingstore_create), 212 },
+{ HP_POP(buyingstore->close), HP_POP2(HP_buyingstore_close), 214 },
+{ HP_POP(buyingstore->open), HP_POP2(HP_buyingstore_open), 216 },
+{ HP_POP(buyingstore->trade), HP_POP2(HP_buyingstore_trade), 218 },
+{ HP_POP(buyingstore->search), HP_POP2(HP_buyingstore_search), 220 },
+{ HP_POP(buyingstore->searchall), HP_POP2(HP_buyingstore_searchall), 222 },
+{ HP_POP(buyingstore->getuid), HP_POP2(HP_buyingstore_getuid), 224 },
+/* chat */
+{ HP_POP(chat->create_pc_chat), HP_POP2(HP_chat_create_pc_chat), 226 },
+{ HP_POP(chat->join), HP_POP2(HP_chat_join), 228 },
+{ HP_POP(chat->leave), HP_POP2(HP_chat_leave), 230 },
+{ HP_POP(chat->change_owner), HP_POP2(HP_chat_change_owner), 232 },
+{ HP_POP(chat->change_status), HP_POP2(HP_chat_change_status), 234 },
+{ HP_POP(chat->kick), HP_POP2(HP_chat_kick), 236 },
+{ HP_POP(chat->create_npc_chat), HP_POP2(HP_chat_create_npc_chat), 238 },
+{ HP_POP(chat->delete_npc_chat), HP_POP2(HP_chat_delete_npc_chat), 240 },
+{ HP_POP(chat->enable_event), HP_POP2(HP_chat_enable_event), 242 },
+{ HP_POP(chat->disable_event), HP_POP2(HP_chat_disable_event), 244 },
+{ HP_POP(chat->npc_kick_all), HP_POP2(HP_chat_npc_kick_all), 246 },
+{ HP_POP(chat->trigger_event), HP_POP2(HP_chat_trigger_event), 248 },
+{ HP_POP(chat->create), HP_POP2(HP_chat_create), 250 },
+/* chrif */
+{ HP_POP(chrif->final), HP_POP2(HP_chrif_final), 252 },
+{ HP_POP(chrif->init), HP_POP2(HP_chrif_init), 254 },
+{ HP_POP(chrif->setuserid), HP_POP2(HP_chrif_setuserid), 256 },
+{ HP_POP(chrif->setpasswd), HP_POP2(HP_chrif_setpasswd), 258 },
+{ HP_POP(chrif->checkdefaultlogin), HP_POP2(HP_chrif_checkdefaultlogin), 260 },
+{ HP_POP(chrif->setip), HP_POP2(HP_chrif_setip), 262 },
+{ HP_POP(chrif->setport), HP_POP2(HP_chrif_setport), 264 },
+{ HP_POP(chrif->isconnected), HP_POP2(HP_chrif_isconnected), 266 },
+{ HP_POP(chrif->check_shutdown), HP_POP2(HP_chrif_check_shutdown), 268 },
+{ HP_POP(chrif->search), HP_POP2(HP_chrif_search), 270 },
+{ HP_POP(chrif->auth_check), HP_POP2(HP_chrif_auth_check), 272 },
+{ HP_POP(chrif->auth_delete), HP_POP2(HP_chrif_auth_delete), 274 },
+{ HP_POP(chrif->auth_finished), HP_POP2(HP_chrif_auth_finished), 276 },
+{ HP_POP(chrif->authreq), HP_POP2(HP_chrif_authreq), 278 },
+{ HP_POP(chrif->authok), HP_POP2(HP_chrif_authok), 280 },
+{ HP_POP(chrif->scdata_request), HP_POP2(HP_chrif_scdata_request), 282 },
+{ HP_POP(chrif->save), HP_POP2(HP_chrif_save), 284 },
+{ HP_POP(chrif->charselectreq), HP_POP2(HP_chrif_charselectreq), 286 },
+{ HP_POP(chrif->changemapserver), HP_POP2(HP_chrif_changemapserver), 288 },
+{ HP_POP(chrif->searchcharid), HP_POP2(HP_chrif_searchcharid), 290 },
+{ HP_POP(chrif->changeemail), HP_POP2(HP_chrif_changeemail), 292 },
+{ HP_POP(chrif->char_ask_name), HP_POP2(HP_chrif_char_ask_name), 294 },
+{ HP_POP(chrif->updatefamelist), HP_POP2(HP_chrif_updatefamelist), 296 },
+{ HP_POP(chrif->buildfamelist), HP_POP2(HP_chrif_buildfamelist), 298 },
+{ HP_POP(chrif->save_scdata), HP_POP2(HP_chrif_save_scdata), 300 },
+{ HP_POP(chrif->ragsrvinfo), HP_POP2(HP_chrif_ragsrvinfo), 302 },
+{ HP_POP(chrif->char_offline), HP_POP2(HP_chrif_char_offline), 304 },
+{ HP_POP(chrif->char_offline_nsd), HP_POP2(HP_chrif_char_offline_nsd), 306 },
+{ HP_POP(chrif->char_reset_offline), HP_POP2(HP_chrif_char_reset_offline), 308 },
+{ HP_POP(chrif->send_users_tochar), HP_POP2(HP_chrif_send_users_tochar), 310 },
+{ HP_POP(chrif->char_online), HP_POP2(HP_chrif_char_online), 312 },
+{ HP_POP(chrif->changesex), HP_POP2(HP_chrif_changesex), 314 },
+{ HP_POP(chrif->divorce), HP_POP2(HP_chrif_divorce), 316 },
+{ HP_POP(chrif->removefriend), HP_POP2(HP_chrif_removefriend), 318 },
+{ HP_POP(chrif->send_report), HP_POP2(HP_chrif_send_report), 320 },
+{ HP_POP(chrif->flush_fifo), HP_POP2(HP_chrif_flush_fifo), 322 },
+{ HP_POP(chrif->skillid2idx), HP_POP2(HP_chrif_skillid2idx), 324 },
+{ HP_POP(chrif->sd_to_auth), HP_POP2(HP_chrif_sd_to_auth), 326 },
+{ HP_POP(chrif->check_connect_char_server), HP_POP2(HP_chrif_check_connect_char_server), 328 },
+{ HP_POP(chrif->auth_logout), HP_POP2(HP_chrif_auth_logout), 330 },
+{ HP_POP(chrif->save_ack), HP_POP2(HP_chrif_save_ack), 332 },
+{ HP_POP(chrif->reconnect), HP_POP2(HP_chrif_reconnect), 334 },
+{ HP_POP(chrif->auth_db_cleanup_sub), HP_POP2(HP_chrif_auth_db_cleanup_sub), 336 },
+{ HP_POP(chrif->char_ask_name_answer), HP_POP2(HP_chrif_char_ask_name_answer), 338 },
+{ HP_POP(chrif->auth_db_final), HP_POP2(HP_chrif_auth_db_final), 340 },
+{ HP_POP(chrif->send_usercount_tochar), HP_POP2(HP_chrif_send_usercount_tochar), 342 },
+{ HP_POP(chrif->auth_db_cleanup), HP_POP2(HP_chrif_auth_db_cleanup), 344 },
+{ HP_POP(chrif->connect), HP_POP2(HP_chrif_connect), 346 },
+{ HP_POP(chrif->connectack), HP_POP2(HP_chrif_connectack), 348 },
+{ HP_POP(chrif->sendmap), HP_POP2(HP_chrif_sendmap), 350 },
+{ HP_POP(chrif->sendmapack), HP_POP2(HP_chrif_sendmapack), 352 },
+{ HP_POP(chrif->recvmap), HP_POP2(HP_chrif_recvmap), 354 },
+{ HP_POP(chrif->changemapserverack), HP_POP2(HP_chrif_changemapserverack), 356 },
+{ HP_POP(chrif->changedsex), HP_POP2(HP_chrif_changedsex), 358 },
+{ HP_POP(chrif->divorceack), HP_POP2(HP_chrif_divorceack), 360 },
+{ HP_POP(chrif->accountban), HP_POP2(HP_chrif_accountban), 362 },
+{ HP_POP(chrif->recvfamelist), HP_POP2(HP_chrif_recvfamelist), 364 },
+{ HP_POP(chrif->load_scdata), HP_POP2(HP_chrif_load_scdata), 366 },
+{ HP_POP(chrif->update_ip), HP_POP2(HP_chrif_update_ip), 368 },
+{ HP_POP(chrif->disconnectplayer), HP_POP2(HP_chrif_disconnectplayer), 370 },
+{ HP_POP(chrif->removemap), HP_POP2(HP_chrif_removemap), 372 },
+{ HP_POP(chrif->updatefamelist_ack), HP_POP2(HP_chrif_updatefamelist_ack), 374 },
+{ HP_POP(chrif->keepalive), HP_POP2(HP_chrif_keepalive), 376 },
+{ HP_POP(chrif->keepalive_ack), HP_POP2(HP_chrif_keepalive_ack), 378 },
+{ HP_POP(chrif->deadopt), HP_POP2(HP_chrif_deadopt), 380 },
+{ HP_POP(chrif->authfail), HP_POP2(HP_chrif_authfail), 382 },
+{ HP_POP(chrif->on_ready), HP_POP2(HP_chrif_on_ready), 384 },
+{ HP_POP(chrif->on_disconnect), HP_POP2(HP_chrif_on_disconnect), 386 },
+{ HP_POP(chrif->parse), HP_POP2(HP_chrif_parse), 388 },
+/* clif */
+{ HP_POP(clif->init), HP_POP2(HP_clif_init), 390 },
+{ HP_POP(clif->final), HP_POP2(HP_clif_final), 392 },
+{ HP_POP(clif->setip), HP_POP2(HP_clif_setip), 394 },
+{ HP_POP(clif->setbindip), HP_POP2(HP_clif_setbindip), 396 },
+{ HP_POP(clif->setport), HP_POP2(HP_clif_setport), 398 },
+{ HP_POP(clif->refresh_ip), HP_POP2(HP_clif_refresh_ip), 400 },
+{ HP_POP(clif->send), HP_POP2(HP_clif_send), 402 },
+{ HP_POP(clif->send_sub), HP_POP2(HP_clif_send_sub), 404 },
+{ HP_POP(clif->parse), HP_POP2(HP_clif_parse), 406 },
+{ HP_POP(clif->parse_cmd), HP_POP2(HP_clif_parse_cmd), 408 },
+{ HP_POP(clif->decrypt_cmd), HP_POP2(HP_clif_decrypt_cmd), 410 },
+{ HP_POP(clif->authok), HP_POP2(HP_clif_authok), 412 },
+{ HP_POP(clif->authrefuse), HP_POP2(HP_clif_authrefuse), 414 },
+{ HP_POP(clif->authfail_fd), HP_POP2(HP_clif_authfail_fd), 416 },
+{ HP_POP(clif->charselectok), HP_POP2(HP_clif_charselectok), 418 },
+{ HP_POP(clif->dropflooritem), HP_POP2(HP_clif_dropflooritem), 420 },
+{ HP_POP(clif->clearflooritem), HP_POP2(HP_clif_clearflooritem), 422 },
+{ HP_POP(clif->additem), HP_POP2(HP_clif_additem), 424 },
+{ HP_POP(clif->dropitem), HP_POP2(HP_clif_dropitem), 426 },
+{ HP_POP(clif->delitem), HP_POP2(HP_clif_delitem), 428 },
+{ HP_POP(clif->takeitem), HP_POP2(HP_clif_takeitem), 430 },
+{ HP_POP(clif->arrowequip), HP_POP2(HP_clif_arrowequip), 432 },
+{ HP_POP(clif->arrow_fail), HP_POP2(HP_clif_arrow_fail), 434 },
+{ HP_POP(clif->use_card), HP_POP2(HP_clif_use_card), 436 },
+{ HP_POP(clif->cart_additem), HP_POP2(HP_clif_cart_additem), 438 },
+{ HP_POP(clif->cart_delitem), HP_POP2(HP_clif_cart_delitem), 440 },
+{ HP_POP(clif->equipitemack), HP_POP2(HP_clif_equipitemack), 442 },
+{ HP_POP(clif->unequipitemack), HP_POP2(HP_clif_unequipitemack), 444 },
+{ HP_POP(clif->useitemack), HP_POP2(HP_clif_useitemack), 446 },
+{ HP_POP(clif->addcards), HP_POP2(HP_clif_addcards), 448 },
+{ HP_POP(clif->addcards2), HP_POP2(HP_clif_addcards2), 450 },
+{ HP_POP(clif->item_sub), HP_POP2(HP_clif_item_sub), 452 },
+{ HP_POP(clif->getareachar_item), HP_POP2(HP_clif_getareachar_item), 454 },
+{ HP_POP(clif->cart_additem_ack), HP_POP2(HP_clif_cart_additem_ack), 456 },
+{ HP_POP(clif->cashshop_load), HP_POP2(HP_clif_cashshop_load), 458 },
+{ HP_POP(clif->package_announce), HP_POP2(HP_clif_package_announce), 460 },
+{ HP_POP(clif->clearunit_single), HP_POP2(HP_clif_clearunit_single), 462 },
+{ HP_POP(clif->clearunit_area), HP_POP2(HP_clif_clearunit_area), 464 },
+{ HP_POP(clif->clearunit_delayed), HP_POP2(HP_clif_clearunit_delayed), 466 },
+{ HP_POP(clif->walkok), HP_POP2(HP_clif_walkok), 468 },
+{ HP_POP(clif->move), HP_POP2(HP_clif_move), 470 },
+{ HP_POP(clif->move2), HP_POP2(HP_clif_move2), 472 },
+{ HP_POP(clif->blown), HP_POP2(HP_clif_blown), 474 },
+{ HP_POP(clif->slide), HP_POP2(HP_clif_slide), 476 },
+{ HP_POP(clif->fixpos), HP_POP2(HP_clif_fixpos), 478 },
+{ HP_POP(clif->changelook), HP_POP2(HP_clif_changelook), 480 },
+{ HP_POP(clif->changetraplook), HP_POP2(HP_clif_changetraplook), 482 },
+{ HP_POP(clif->refreshlook), HP_POP2(HP_clif_refreshlook), 484 },
+{ HP_POP(clif->class_change), HP_POP2(HP_clif_class_change), 486 },
+{ HP_POP(clif->skill_setunit), HP_POP2(HP_clif_skill_setunit), 488 },
+{ HP_POP(clif->skill_delunit), HP_POP2(HP_clif_skill_delunit), 490 },
+{ HP_POP(clif->skillunit_update), HP_POP2(HP_clif_skillunit_update), 492 },
+{ HP_POP(clif->clearunit_delayed_sub), HP_POP2(HP_clif_clearunit_delayed_sub), 494 },
+{ HP_POP(clif->set_unit_idle), HP_POP2(HP_clif_set_unit_idle), 496 },
+{ HP_POP(clif->spawn_unit), HP_POP2(HP_clif_spawn_unit), 498 },
+{ HP_POP(clif->set_unit_walking), HP_POP2(HP_clif_set_unit_walking), 500 },
+{ HP_POP(clif->calc_walkdelay), HP_POP2(HP_clif_calc_walkdelay), 502 },
+{ HP_POP(clif->getareachar_skillunit), HP_POP2(HP_clif_getareachar_skillunit), 504 },
+{ HP_POP(clif->getareachar_unit), HP_POP2(HP_clif_getareachar_unit), 506 },
+{ HP_POP(clif->clearchar_skillunit), HP_POP2(HP_clif_clearchar_skillunit), 508 },
+{ HP_POP(clif->getareachar), HP_POP2(HP_clif_getareachar), 510 },
+{ HP_POP(clif->spawn), HP_POP2(HP_clif_spawn), 512 },
+{ HP_POP(clif->changemap), HP_POP2(HP_clif_changemap), 514 },
+{ HP_POP(clif->changemapcell), HP_POP2(HP_clif_changemapcell), 516 },
+{ HP_POP(clif->map_property), HP_POP2(HP_clif_map_property), 518 },
+{ HP_POP(clif->pvpset), HP_POP2(HP_clif_pvpset), 520 },
+{ HP_POP(clif->map_property_mapall), HP_POP2(HP_clif_map_property_mapall), 522 },
+{ HP_POP(clif->bossmapinfo), HP_POP2(HP_clif_bossmapinfo), 524 },
+{ HP_POP(clif->map_type), HP_POP2(HP_clif_map_type), 526 },
+{ HP_POP(clif->maptypeproperty2), HP_POP2(HP_clif_maptypeproperty2), 528 },
+{ HP_POP(clif->changemapserver), HP_POP2(HP_clif_changemapserver), 530 },
+{ HP_POP(clif->npcbuysell), HP_POP2(HP_clif_npcbuysell), 532 },
+{ HP_POP(clif->buylist), HP_POP2(HP_clif_buylist), 534 },
+{ HP_POP(clif->selllist), HP_POP2(HP_clif_selllist), 536 },
+{ HP_POP(clif->cashshop_show), HP_POP2(HP_clif_cashshop_show), 538 },
+{ HP_POP(clif->npc_buy_result), HP_POP2(HP_clif_npc_buy_result), 540 },
+{ HP_POP(clif->npc_sell_result), HP_POP2(HP_clif_npc_sell_result), 542 },
+{ HP_POP(clif->cashshop_ack), HP_POP2(HP_clif_cashshop_ack), 544 },
+{ HP_POP(clif->scriptmes), HP_POP2(HP_clif_scriptmes), 546 },
+{ HP_POP(clif->scriptnext), HP_POP2(HP_clif_scriptnext), 548 },
+{ HP_POP(clif->scriptclose), HP_POP2(HP_clif_scriptclose), 550 },
+{ HP_POP(clif->scriptmenu), HP_POP2(HP_clif_scriptmenu), 552 },
+{ HP_POP(clif->scriptinput), HP_POP2(HP_clif_scriptinput), 554 },
+{ HP_POP(clif->scriptinputstr), HP_POP2(HP_clif_scriptinputstr), 556 },
+{ HP_POP(clif->cutin), HP_POP2(HP_clif_cutin), 558 },
+{ HP_POP(clif->sendfakenpc), HP_POP2(HP_clif_sendfakenpc), 560 },
+{ HP_POP(clif->scriptclear), HP_POP2(HP_clif_scriptclear), 562 },
+{ HP_POP(clif->viewpoint), HP_POP2(HP_clif_viewpoint), 564 },
+{ HP_POP(clif->damage), HP_POP2(HP_clif_damage), 566 },
+{ HP_POP(clif->sitting), HP_POP2(HP_clif_sitting), 568 },
+{ HP_POP(clif->standing), HP_POP2(HP_clif_standing), 570 },
+{ HP_POP(clif->arrow_create_list), HP_POP2(HP_clif_arrow_create_list), 572 },
+{ HP_POP(clif->refresh), HP_POP2(HP_clif_refresh), 574 },
+{ HP_POP(clif->fame_blacksmith), HP_POP2(HP_clif_fame_blacksmith), 576 },
+{ HP_POP(clif->fame_alchemist), HP_POP2(HP_clif_fame_alchemist), 578 },
+{ HP_POP(clif->fame_taekwon), HP_POP2(HP_clif_fame_taekwon), 580 },
+{ HP_POP(clif->ranklist), HP_POP2(HP_clif_ranklist), 582 },
+{ HP_POP(clif->update_rankingpoint), HP_POP2(HP_clif_update_rankingpoint), 584 },
+{ HP_POP(clif->pRanklist), HP_POP2(HP_clif_pRanklist), 586 },
+{ HP_POP(clif->hotkeys), HP_POP2(HP_clif_hotkeys), 588 },
+{ HP_POP(clif->insight), HP_POP2(HP_clif_insight), 590 },
+{ HP_POP(clif->outsight), HP_POP2(HP_clif_outsight), 592 },
+{ HP_POP(clif->skillcastcancel), HP_POP2(HP_clif_skillcastcancel), 594 },
+{ HP_POP(clif->skill_fail), HP_POP2(HP_clif_skill_fail), 596 },
+{ HP_POP(clif->skill_cooldown), HP_POP2(HP_clif_skill_cooldown), 598 },
+{ HP_POP(clif->skill_memomessage), HP_POP2(HP_clif_skill_memomessage), 600 },
+{ HP_POP(clif->skill_mapinfomessage), HP_POP2(HP_clif_skill_mapinfomessage), 602 },
+{ HP_POP(clif->skill_produce_mix_list), HP_POP2(HP_clif_skill_produce_mix_list), 604 },
+{ HP_POP(clif->cooking_list), HP_POP2(HP_clif_cooking_list), 606 },
+{ HP_POP(clif->autospell), HP_POP2(HP_clif_autospell), 608 },
+{ HP_POP(clif->combo_delay), HP_POP2(HP_clif_combo_delay), 610 },
+{ HP_POP(clif->status_change), HP_POP2(HP_clif_status_change), 612 },
+{ HP_POP(clif->insert_card), HP_POP2(HP_clif_insert_card), 614 },
+{ HP_POP(clif->inventorylist), HP_POP2(HP_clif_inventorylist), 616 },
+{ HP_POP(clif->equiplist), HP_POP2(HP_clif_equiplist), 618 },
+{ HP_POP(clif->cartlist), HP_POP2(HP_clif_cartlist), 620 },
+{ HP_POP(clif->favorite_item), HP_POP2(HP_clif_favorite_item), 622 },
+{ HP_POP(clif->clearcart), HP_POP2(HP_clif_clearcart), 624 },
+{ HP_POP(clif->item_identify_list), HP_POP2(HP_clif_item_identify_list), 626 },
+{ HP_POP(clif->item_identified), HP_POP2(HP_clif_item_identified), 628 },
+{ HP_POP(clif->item_repair_list), HP_POP2(HP_clif_item_repair_list), 630 },
+{ HP_POP(clif->item_repaireffect), HP_POP2(HP_clif_item_repaireffect), 632 },
+{ HP_POP(clif->item_damaged), HP_POP2(HP_clif_item_damaged), 634 },
+{ HP_POP(clif->item_refine_list), HP_POP2(HP_clif_item_refine_list), 636 },
+{ HP_POP(clif->item_skill), HP_POP2(HP_clif_item_skill), 638 },
+{ HP_POP(clif->mvp_item), HP_POP2(HP_clif_mvp_item), 640 },
+{ HP_POP(clif->mvp_exp), HP_POP2(HP_clif_mvp_exp), 642 },
+{ HP_POP(clif->mvp_noitem), HP_POP2(HP_clif_mvp_noitem), 644 },
+{ HP_POP(clif->changed_dir), HP_POP2(HP_clif_changed_dir), 646 },
+{ HP_POP(clif->charnameack), HP_POP2(HP_clif_charnameack), 648 },
+{ HP_POP(clif->monster_hp_bar), HP_POP2(HP_clif_monster_hp_bar), 650 },
+{ HP_POP(clif->hpmeter), HP_POP2(HP_clif_hpmeter), 652 },
+{ HP_POP(clif->hpmeter_single), HP_POP2(HP_clif_hpmeter_single), 654 },
+{ HP_POP(clif->hpmeter_sub), HP_POP2(HP_clif_hpmeter_sub), 656 },
+{ HP_POP(clif->upgrademessage), HP_POP2(HP_clif_upgrademessage), 658 },
+{ HP_POP(clif->get_weapon_view), HP_POP2(HP_clif_get_weapon_view), 660 },
+{ HP_POP(clif->gospel_info), HP_POP2(HP_clif_gospel_info), 662 },
+{ HP_POP(clif->feel_req), HP_POP2(HP_clif_feel_req), 664 },
+{ HP_POP(clif->starskill), HP_POP2(HP_clif_starskill), 666 },
+{ HP_POP(clif->feel_info), HP_POP2(HP_clif_feel_info), 668 },
+{ HP_POP(clif->hate_info), HP_POP2(HP_clif_hate_info), 670 },
+{ HP_POP(clif->mission_info), HP_POP2(HP_clif_mission_info), 672 },
+{ HP_POP(clif->feel_hate_reset), HP_POP2(HP_clif_feel_hate_reset), 674 },
+{ HP_POP(clif->partytickack), HP_POP2(HP_clif_partytickack), 676 },
+{ HP_POP(clif->equiptickack), HP_POP2(HP_clif_equiptickack), 678 },
+{ HP_POP(clif->viewequip_ack), HP_POP2(HP_clif_viewequip_ack), 680 },
+{ HP_POP(clif->viewequip_fail), HP_POP2(HP_clif_viewequip_fail), 682 },
+{ HP_POP(clif->equpcheckbox), HP_POP2(HP_clif_equpcheckbox), 684 },
+{ HP_POP(clif->displayexp), HP_POP2(HP_clif_displayexp), 686 },
+{ HP_POP(clif->font), HP_POP2(HP_clif_font), 688 },
+{ HP_POP(clif->progressbar), HP_POP2(HP_clif_progressbar), 690 },
+{ HP_POP(clif->progressbar_abort), HP_POP2(HP_clif_progressbar_abort), 692 },
+{ HP_POP(clif->showdigit), HP_POP2(HP_clif_showdigit), 694 },
+{ HP_POP(clif->elementalconverter_list), HP_POP2(HP_clif_elementalconverter_list), 696 },
+{ HP_POP(clif->spellbook_list), HP_POP2(HP_clif_spellbook_list), 698 },
+{ HP_POP(clif->magicdecoy_list), HP_POP2(HP_clif_magicdecoy_list), 700 },
+{ HP_POP(clif->poison_list), HP_POP2(HP_clif_poison_list), 702 },
+{ HP_POP(clif->autoshadowspell_list), HP_POP2(HP_clif_autoshadowspell_list), 704 },
+{ HP_POP(clif->skill_itemlistwindow), HP_POP2(HP_clif_skill_itemlistwindow), 706 },
+{ HP_POP(clif->sc_load), HP_POP2(HP_clif_sc_load), 708 },
+{ HP_POP(clif->sc_end), HP_POP2(HP_clif_sc_end), 710 },
+{ HP_POP(clif->initialstatus), HP_POP2(HP_clif_initialstatus), 712 },
+{ HP_POP(clif->cooldown_list), HP_POP2(HP_clif_cooldown_list), 714 },
+{ HP_POP(clif->updatestatus), HP_POP2(HP_clif_updatestatus), 716 },
+{ HP_POP(clif->changestatus), HP_POP2(HP_clif_changestatus), 718 },
+{ HP_POP(clif->statusupack), HP_POP2(HP_clif_statusupack), 720 },
+{ HP_POP(clif->movetoattack), HP_POP2(HP_clif_movetoattack), 722 },
+{ HP_POP(clif->solved_charname), HP_POP2(HP_clif_solved_charname), 724 },
+{ HP_POP(clif->charnameupdate), HP_POP2(HP_clif_charnameupdate), 726 },
+{ HP_POP(clif->delayquit), HP_POP2(HP_clif_delayquit), 728 },
+{ HP_POP(clif->getareachar_pc), HP_POP2(HP_clif_getareachar_pc), 730 },
+{ HP_POP(clif->disconnect_ack), HP_POP2(HP_clif_disconnect_ack), 732 },
+{ HP_POP(clif->PVPInfo), HP_POP2(HP_clif_PVPInfo), 734 },
+{ HP_POP(clif->blacksmith), HP_POP2(HP_clif_blacksmith), 736 },
+{ HP_POP(clif->alchemist), HP_POP2(HP_clif_alchemist), 738 },
+{ HP_POP(clif->taekwon), HP_POP2(HP_clif_taekwon), 740 },
+{ HP_POP(clif->ranking_pk), HP_POP2(HP_clif_ranking_pk), 742 },
+{ HP_POP(clif->quitsave), HP_POP2(HP_clif_quitsave), 744 },
+{ HP_POP(clif->misceffect), HP_POP2(HP_clif_misceffect), 746 },
+{ HP_POP(clif->changeoption), HP_POP2(HP_clif_changeoption), 748 },
+{ HP_POP(clif->changeoption2), HP_POP2(HP_clif_changeoption2), 750 },
+{ HP_POP(clif->emotion), HP_POP2(HP_clif_emotion), 752 },
+{ HP_POP(clif->talkiebox), HP_POP2(HP_clif_talkiebox), 754 },
+{ HP_POP(clif->wedding_effect), HP_POP2(HP_clif_wedding_effect), 756 },
+{ HP_POP(clif->divorced), HP_POP2(HP_clif_divorced), 758 },
+{ HP_POP(clif->callpartner), HP_POP2(HP_clif_callpartner), 760 },
+{ HP_POP(clif->skill_damage), HP_POP2(HP_clif_skill_damage), 762 },
+{ HP_POP(clif->skill_nodamage), HP_POP2(HP_clif_skill_nodamage), 764 },
+{ HP_POP(clif->skill_poseffect), HP_POP2(HP_clif_skill_poseffect), 766 },
+{ HP_POP(clif->skill_estimation), HP_POP2(HP_clif_skill_estimation), 768 },
+{ HP_POP(clif->skill_warppoint), HP_POP2(HP_clif_skill_warppoint), 770 },
+{ HP_POP(clif->skillcasting), HP_POP2(HP_clif_skillcasting), 772 },
+{ HP_POP(clif->produce_effect), HP_POP2(HP_clif_produce_effect), 774 },
+{ HP_POP(clif->devotion), HP_POP2(HP_clif_devotion), 776 },
+{ HP_POP(clif->spiritball), HP_POP2(HP_clif_spiritball), 778 },
+{ HP_POP(clif->spiritball_single), HP_POP2(HP_clif_spiritball_single), 780 },
+{ HP_POP(clif->bladestop), HP_POP2(HP_clif_bladestop), 782 },
+{ HP_POP(clif->mvp_effect), HP_POP2(HP_clif_mvp_effect), 784 },
+{ HP_POP(clif->heal), HP_POP2(HP_clif_heal), 786 },
+{ HP_POP(clif->resurrection), HP_POP2(HP_clif_resurrection), 788 },
+{ HP_POP(clif->refine), HP_POP2(HP_clif_refine), 790 },
+{ HP_POP(clif->weather), HP_POP2(HP_clif_weather), 792 },
+{ HP_POP(clif->specialeffect), HP_POP2(HP_clif_specialeffect), 794 },
+{ HP_POP(clif->specialeffect_single), HP_POP2(HP_clif_specialeffect_single), 796 },
+{ HP_POP(clif->specialeffect_value), HP_POP2(HP_clif_specialeffect_value), 798 },
+{ HP_POP(clif->millenniumshield), HP_POP2(HP_clif_millenniumshield), 800 },
+{ HP_POP(clif->charm), HP_POP2(HP_clif_charm), 802 },
+{ HP_POP(clif->charm_single), HP_POP2(HP_clif_charm_single), 804 },
+{ HP_POP(clif->snap), HP_POP2(HP_clif_snap), 806 },
+{ HP_POP(clif->weather_check), HP_POP2(HP_clif_weather_check), 808 },
+{ HP_POP(clif->playBGM), HP_POP2(HP_clif_playBGM), 810 },
+{ HP_POP(clif->soundeffect), HP_POP2(HP_clif_soundeffect), 812 },
+{ HP_POP(clif->soundeffectall), HP_POP2(HP_clif_soundeffectall), 814 },
+{ HP_POP(clif->GlobalMessage), HP_POP2(HP_clif_GlobalMessage), 816 },
+{ HP_POP(clif->createchat), HP_POP2(HP_clif_createchat), 818 },
+{ HP_POP(clif->dispchat), HP_POP2(HP_clif_dispchat), 820 },
+{ HP_POP(clif->joinchatfail), HP_POP2(HP_clif_joinchatfail), 822 },
+{ HP_POP(clif->joinchatok), HP_POP2(HP_clif_joinchatok), 824 },
+{ HP_POP(clif->addchat), HP_POP2(HP_clif_addchat), 826 },
+{ HP_POP(clif->changechatowner), HP_POP2(HP_clif_changechatowner), 828 },
+{ HP_POP(clif->clearchat), HP_POP2(HP_clif_clearchat), 830 },
+{ HP_POP(clif->leavechat), HP_POP2(HP_clif_leavechat), 832 },
+{ HP_POP(clif->changechatstatus), HP_POP2(HP_clif_changechatstatus), 834 },
+{ HP_POP(clif->wis_message), HP_POP2(HP_clif_wis_message), 836 },
+{ HP_POP(clif->wis_end), HP_POP2(HP_clif_wis_end), 838 },
+{ HP_POP(clif->disp_onlyself), HP_POP2(HP_clif_disp_onlyself), 840 },
+{ HP_POP(clif->disp_message), HP_POP2(HP_clif_disp_message), 842 },
+{ HP_POP(clif->broadcast), HP_POP2(HP_clif_broadcast), 844 },
+{ HP_POP(clif->broadcast2), HP_POP2(HP_clif_broadcast2), 846 },
+{ HP_POP(clif->messagecolor), HP_POP2(HP_clif_messagecolor), 848 },
+{ HP_POP(clif->disp_overhead), HP_POP2(HP_clif_disp_overhead), 850 },
+{ HP_POP(clif->msg), HP_POP2(HP_clif_msg), 852 },
+{ HP_POP(clif->msg_value), HP_POP2(HP_clif_msg_value), 854 },
+{ HP_POP(clif->msg_skill), HP_POP2(HP_clif_msg_skill), 856 },
+{ HP_POP(clif->msgtable), HP_POP2(HP_clif_msgtable), 858 },
+{ HP_POP(clif->msgtable_num), HP_POP2(HP_clif_msgtable_num), 860 },
+{ HP_POP(clif->message), HP_POP2(HP_clif_message), 862 },
+{ HP_POP(clif->messageln), HP_POP2(HP_clif_messageln), 864 },
+{ HP_POP(clif->colormes), HP_POP2(HP_clif_colormes), 866 },
+{ HP_POP(clif->process_message), HP_POP2(HP_clif_process_message), 868 },
+{ HP_POP(clif->wisexin), HP_POP2(HP_clif_wisexin), 870 },
+{ HP_POP(clif->wisall), HP_POP2(HP_clif_wisall), 872 },
+{ HP_POP(clif->PMIgnoreList), HP_POP2(HP_clif_PMIgnoreList), 874 },
+{ HP_POP(clif->traderequest), HP_POP2(HP_clif_traderequest), 876 },
+{ HP_POP(clif->tradestart), HP_POP2(HP_clif_tradestart), 878 },
+{ HP_POP(clif->tradeadditem), HP_POP2(HP_clif_tradeadditem), 880 },
+{ HP_POP(clif->tradeitemok), HP_POP2(HP_clif_tradeitemok), 882 },
+{ HP_POP(clif->tradedeal_lock), HP_POP2(HP_clif_tradedeal_lock), 884 },
+{ HP_POP(clif->tradecancelled), HP_POP2(HP_clif_tradecancelled), 886 },
+{ HP_POP(clif->tradecompleted), HP_POP2(HP_clif_tradecompleted), 888 },
+{ HP_POP(clif->tradeundo), HP_POP2(HP_clif_tradeundo), 890 },
+{ HP_POP(clif->openvendingreq), HP_POP2(HP_clif_openvendingreq), 892 },
+{ HP_POP(clif->showvendingboard), HP_POP2(HP_clif_showvendingboard), 894 },
+{ HP_POP(clif->closevendingboard), HP_POP2(HP_clif_closevendingboard), 896 },
+{ HP_POP(clif->vendinglist), HP_POP2(HP_clif_vendinglist), 898 },
+{ HP_POP(clif->buyvending), HP_POP2(HP_clif_buyvending), 900 },
+{ HP_POP(clif->openvending), HP_POP2(HP_clif_openvending), 902 },
+{ HP_POP(clif->vendingreport), HP_POP2(HP_clif_vendingreport), 904 },
+{ HP_POP(clif->storagelist), HP_POP2(HP_clif_storagelist), 906 },
+{ HP_POP(clif->updatestorageamount), HP_POP2(HP_clif_updatestorageamount), 908 },
+{ HP_POP(clif->storageitemadded), HP_POP2(HP_clif_storageitemadded), 910 },
+{ HP_POP(clif->storageitemremoved), HP_POP2(HP_clif_storageitemremoved), 912 },
+{ HP_POP(clif->storageclose), HP_POP2(HP_clif_storageclose), 914 },
+{ HP_POP(clif->skillinfoblock), HP_POP2(HP_clif_skillinfoblock), 916 },
+{ HP_POP(clif->skillup), HP_POP2(HP_clif_skillup), 918 },
+{ HP_POP(clif->skillinfo), HP_POP2(HP_clif_skillinfo), 920 },
+{ HP_POP(clif->addskill), HP_POP2(HP_clif_addskill), 922 },
+{ HP_POP(clif->deleteskill), HP_POP2(HP_clif_deleteskill), 924 },
+{ HP_POP(clif->party_created), HP_POP2(HP_clif_party_created), 926 },
+{ HP_POP(clif->party_member_info), HP_POP2(HP_clif_party_member_info), 928 },
+{ HP_POP(clif->party_info), HP_POP2(HP_clif_party_info), 930 },
+{ HP_POP(clif->party_invite), HP_POP2(HP_clif_party_invite), 932 },
+{ HP_POP(clif->party_inviteack), HP_POP2(HP_clif_party_inviteack), 934 },
+{ HP_POP(clif->party_option), HP_POP2(HP_clif_party_option), 936 },
+{ HP_POP(clif->party_withdraw), HP_POP2(HP_clif_party_withdraw), 938 },
+{ HP_POP(clif->party_message), HP_POP2(HP_clif_party_message), 940 },
+{ HP_POP(clif->party_xy), HP_POP2(HP_clif_party_xy), 942 },
+{ HP_POP(clif->party_xy_single), HP_POP2(HP_clif_party_xy_single), 944 },
+{ HP_POP(clif->party_hp), HP_POP2(HP_clif_party_hp), 946 },
+{ HP_POP(clif->party_xy_remove), HP_POP2(HP_clif_party_xy_remove), 948 },
+{ HP_POP(clif->party_show_picker), HP_POP2(HP_clif_party_show_picker), 950 },
+{ HP_POP(clif->partyinvitationstate), HP_POP2(HP_clif_partyinvitationstate), 952 },
+{ HP_POP(clif->guild_created), HP_POP2(HP_clif_guild_created), 954 },
+{ HP_POP(clif->guild_belonginfo), HP_POP2(HP_clif_guild_belonginfo), 956 },
+{ HP_POP(clif->guild_masterormember), HP_POP2(HP_clif_guild_masterormember), 958 },
+{ HP_POP(clif->guild_basicinfo), HP_POP2(HP_clif_guild_basicinfo), 960 },
+{ HP_POP(clif->guild_allianceinfo), HP_POP2(HP_clif_guild_allianceinfo), 962 },
+{ HP_POP(clif->guild_memberlist), HP_POP2(HP_clif_guild_memberlist), 964 },
+{ HP_POP(clif->guild_skillinfo), HP_POP2(HP_clif_guild_skillinfo), 966 },
+{ HP_POP(clif->guild_send_onlineinfo), HP_POP2(HP_clif_guild_send_onlineinfo), 968 },
+{ HP_POP(clif->guild_memberlogin_notice), HP_POP2(HP_clif_guild_memberlogin_notice), 970 },
+{ HP_POP(clif->guild_invite), HP_POP2(HP_clif_guild_invite), 972 },
+{ HP_POP(clif->guild_inviteack), HP_POP2(HP_clif_guild_inviteack), 974 },
+{ HP_POP(clif->guild_leave), HP_POP2(HP_clif_guild_leave), 976 },
+{ HP_POP(clif->guild_expulsion), HP_POP2(HP_clif_guild_expulsion), 978 },
+{ HP_POP(clif->guild_positionchanged), HP_POP2(HP_clif_guild_positionchanged), 980 },
+{ HP_POP(clif->guild_memberpositionchanged), HP_POP2(HP_clif_guild_memberpositionchanged), 982 },
+{ HP_POP(clif->guild_emblem), HP_POP2(HP_clif_guild_emblem), 984 },
+{ HP_POP(clif->guild_emblem_area), HP_POP2(HP_clif_guild_emblem_area), 986 },
+{ HP_POP(clif->guild_notice), HP_POP2(HP_clif_guild_notice), 988 },
+{ HP_POP(clif->guild_message), HP_POP2(HP_clif_guild_message), 990 },
+{ HP_POP(clif->guild_skillup), HP_POP2(HP_clif_guild_skillup), 992 },
+{ HP_POP(clif->guild_reqalliance), HP_POP2(HP_clif_guild_reqalliance), 994 },
+{ HP_POP(clif->guild_allianceack), HP_POP2(HP_clif_guild_allianceack), 996 },
+{ HP_POP(clif->guild_delalliance), HP_POP2(HP_clif_guild_delalliance), 998 },
+{ HP_POP(clif->guild_oppositionack), HP_POP2(HP_clif_guild_oppositionack), 1000 },
+{ HP_POP(clif->guild_broken), HP_POP2(HP_clif_guild_broken), 1002 },
+{ HP_POP(clif->guild_xy), HP_POP2(HP_clif_guild_xy), 1004 },
+{ HP_POP(clif->guild_xy_single), HP_POP2(HP_clif_guild_xy_single), 1006 },
+{ HP_POP(clif->guild_xy_remove), HP_POP2(HP_clif_guild_xy_remove), 1008 },
+{ HP_POP(clif->guild_positionnamelist), HP_POP2(HP_clif_guild_positionnamelist), 1010 },
+{ HP_POP(clif->guild_positioninfolist), HP_POP2(HP_clif_guild_positioninfolist), 1012 },
+{ HP_POP(clif->guild_expulsionlist), HP_POP2(HP_clif_guild_expulsionlist), 1014 },
+{ HP_POP(clif->validate_emblem), HP_POP2(HP_clif_validate_emblem), 1016 },
+{ HP_POP(clif->bg_hp), HP_POP2(HP_clif_bg_hp), 1018 },
+{ HP_POP(clif->bg_xy), HP_POP2(HP_clif_bg_xy), 1020 },
+{ HP_POP(clif->bg_xy_remove), HP_POP2(HP_clif_bg_xy_remove), 1022 },
+{ HP_POP(clif->bg_message), HP_POP2(HP_clif_bg_message), 1024 },
+{ HP_POP(clif->bg_updatescore), HP_POP2(HP_clif_bg_updatescore), 1026 },
+{ HP_POP(clif->bg_updatescore_single), HP_POP2(HP_clif_bg_updatescore_single), 1028 },
+{ HP_POP(clif->sendbgemblem_area), HP_POP2(HP_clif_sendbgemblem_area), 1030 },
+{ HP_POP(clif->sendbgemblem_single), HP_POP2(HP_clif_sendbgemblem_single), 1032 },
+{ HP_POP(clif->instance), HP_POP2(HP_clif_instance), 1034 },
+{ HP_POP(clif->instance_join), HP_POP2(HP_clif_instance_join), 1036 },
+{ HP_POP(clif->instance_leave), HP_POP2(HP_clif_instance_leave), 1038 },
+{ HP_POP(clif->catch_process), HP_POP2(HP_clif_catch_process), 1040 },
+{ HP_POP(clif->pet_roulette), HP_POP2(HP_clif_pet_roulette), 1042 },
+{ HP_POP(clif->sendegg), HP_POP2(HP_clif_sendegg), 1044 },
+{ HP_POP(clif->send_petstatus), HP_POP2(HP_clif_send_petstatus), 1046 },
+{ HP_POP(clif->send_petdata), HP_POP2(HP_clif_send_petdata), 1048 },
+{ HP_POP(clif->pet_emotion), HP_POP2(HP_clif_pet_emotion), 1050 },
+{ HP_POP(clif->pet_food), HP_POP2(HP_clif_pet_food), 1052 },
+{ HP_POP(clif->friendslist_toggle_sub), HP_POP2(HP_clif_friendslist_toggle_sub), 1054 },
+{ HP_POP(clif->friendslist_send), HP_POP2(HP_clif_friendslist_send), 1056 },
+{ HP_POP(clif->friendslist_reqack), HP_POP2(HP_clif_friendslist_reqack), 1058 },
+{ HP_POP(clif->friendslist_toggle), HP_POP2(HP_clif_friendslist_toggle), 1060 },
+{ HP_POP(clif->friendlist_req), HP_POP2(HP_clif_friendlist_req), 1062 },
+{ HP_POP(clif->GM_kickack), HP_POP2(HP_clif_GM_kickack), 1064 },
+{ HP_POP(clif->GM_kick), HP_POP2(HP_clif_GM_kick), 1066 },
+{ HP_POP(clif->manner_message), HP_POP2(HP_clif_manner_message), 1068 },
+{ HP_POP(clif->GM_silence), HP_POP2(HP_clif_GM_silence), 1070 },
+{ HP_POP(clif->account_name), HP_POP2(HP_clif_account_name), 1072 },
+{ HP_POP(clif->check), HP_POP2(HP_clif_check), 1074 },
+{ HP_POP(clif->hominfo), HP_POP2(HP_clif_hominfo), 1076 },
+{ HP_POP(clif->homskillinfoblock), HP_POP2(HP_clif_homskillinfoblock), 1078 },
+{ HP_POP(clif->homskillup), HP_POP2(HP_clif_homskillup), 1080 },
+{ HP_POP(clif->hom_food), HP_POP2(HP_clif_hom_food), 1082 },
+{ HP_POP(clif->send_homdata), HP_POP2(HP_clif_send_homdata), 1084 },
+{ HP_POP(clif->quest_send_list), HP_POP2(HP_clif_quest_send_list), 1086 },
+{ HP_POP(clif->quest_send_mission), HP_POP2(HP_clif_quest_send_mission), 1088 },
+{ HP_POP(clif->quest_add), HP_POP2(HP_clif_quest_add), 1090 },
+{ HP_POP(clif->quest_delete), HP_POP2(HP_clif_quest_delete), 1092 },
+{ HP_POP(clif->quest_update_status), HP_POP2(HP_clif_quest_update_status), 1094 },
+{ HP_POP(clif->quest_update_objective), HP_POP2(HP_clif_quest_update_objective), 1096 },
+{ HP_POP(clif->quest_show_event), HP_POP2(HP_clif_quest_show_event), 1098 },
+{ HP_POP(clif->mail_window), HP_POP2(HP_clif_mail_window), 1100 },
+{ HP_POP(clif->mail_read), HP_POP2(HP_clif_mail_read), 1102 },
+{ HP_POP(clif->mail_delete), HP_POP2(HP_clif_mail_delete), 1104 },
+{ HP_POP(clif->mail_return), HP_POP2(HP_clif_mail_return), 1106 },
+{ HP_POP(clif->mail_send), HP_POP2(HP_clif_mail_send), 1108 },
+{ HP_POP(clif->mail_new), HP_POP2(HP_clif_mail_new), 1110 },
+{ HP_POP(clif->mail_refreshinbox), HP_POP2(HP_clif_mail_refreshinbox), 1112 },
+{ HP_POP(clif->mail_getattachment), HP_POP2(HP_clif_mail_getattachment), 1114 },
+{ HP_POP(clif->mail_setattachment), HP_POP2(HP_clif_mail_setattachment), 1116 },
+{ HP_POP(clif->auction_openwindow), HP_POP2(HP_clif_auction_openwindow), 1118 },
+{ HP_POP(clif->auction_results), HP_POP2(HP_clif_auction_results), 1120 },
+{ HP_POP(clif->auction_message), HP_POP2(HP_clif_auction_message), 1122 },
+{ HP_POP(clif->auction_close), HP_POP2(HP_clif_auction_close), 1124 },
+{ HP_POP(clif->auction_setitem), HP_POP2(HP_clif_auction_setitem), 1126 },
+{ HP_POP(clif->mercenary_info), HP_POP2(HP_clif_mercenary_info), 1128 },
+{ HP_POP(clif->mercenary_skillblock), HP_POP2(HP_clif_mercenary_skillblock), 1130 },
+{ HP_POP(clif->mercenary_message), HP_POP2(HP_clif_mercenary_message), 1132 },
+{ HP_POP(clif->mercenary_updatestatus), HP_POP2(HP_clif_mercenary_updatestatus), 1134 },
+{ HP_POP(clif->rental_time), HP_POP2(HP_clif_rental_time), 1136 },
+{ HP_POP(clif->rental_expired), HP_POP2(HP_clif_rental_expired), 1138 },
+{ HP_POP(clif->PartyBookingRegisterAck), HP_POP2(HP_clif_PartyBookingRegisterAck), 1140 },
+{ HP_POP(clif->PartyBookingDeleteAck), HP_POP2(HP_clif_PartyBookingDeleteAck), 1142 },
+{ HP_POP(clif->PartyBookingSearchAck), HP_POP2(HP_clif_PartyBookingSearchAck), 1144 },
+{ HP_POP(clif->PartyBookingUpdateNotify), HP_POP2(HP_clif_PartyBookingUpdateNotify), 1146 },
+{ HP_POP(clif->PartyBookingDeleteNotify), HP_POP2(HP_clif_PartyBookingDeleteNotify), 1148 },
+{ HP_POP(clif->PartyBookingInsertNotify), HP_POP2(HP_clif_PartyBookingInsertNotify), 1150 },
+{ HP_POP(clif->PartyBookingVolunteerInfo), HP_POP2(HP_clif_PartyBookingVolunteerInfo), 1152 },
+{ HP_POP(clif->PartyBookingRefuseVolunteer), HP_POP2(HP_clif_PartyBookingRefuseVolunteer), 1154 },
+{ HP_POP(clif->PartyBookingCancelVolunteer), HP_POP2(HP_clif_PartyBookingCancelVolunteer), 1156 },
+{ HP_POP(clif->PartyBookingAddFilteringList), HP_POP2(HP_clif_PartyBookingAddFilteringList), 1158 },
+{ HP_POP(clif->PartyBookingSubFilteringList), HP_POP2(HP_clif_PartyBookingSubFilteringList), 1160 },
+{ HP_POP(clif->buyingstore_open), HP_POP2(HP_clif_buyingstore_open), 1162 },
+{ HP_POP(clif->buyingstore_open_failed), HP_POP2(HP_clif_buyingstore_open_failed), 1164 },
+{ HP_POP(clif->buyingstore_myitemlist), HP_POP2(HP_clif_buyingstore_myitemlist), 1166 },
+{ HP_POP(clif->buyingstore_entry), HP_POP2(HP_clif_buyingstore_entry), 1168 },
+{ HP_POP(clif->buyingstore_entry_single), HP_POP2(HP_clif_buyingstore_entry_single), 1170 },
+{ HP_POP(clif->buyingstore_disappear_entry), HP_POP2(HP_clif_buyingstore_disappear_entry), 1172 },
+{ HP_POP(clif->buyingstore_disappear_entry_single), HP_POP2(HP_clif_buyingstore_disappear_entry_single), 1174 },
+{ HP_POP(clif->buyingstore_itemlist), HP_POP2(HP_clif_buyingstore_itemlist), 1176 },
+{ HP_POP(clif->buyingstore_trade_failed_buyer), HP_POP2(HP_clif_buyingstore_trade_failed_buyer), 1178 },
+{ HP_POP(clif->buyingstore_update_item), HP_POP2(HP_clif_buyingstore_update_item), 1180 },
+{ HP_POP(clif->buyingstore_delete_item), HP_POP2(HP_clif_buyingstore_delete_item), 1182 },
+{ HP_POP(clif->buyingstore_trade_failed_seller), HP_POP2(HP_clif_buyingstore_trade_failed_seller), 1184 },
+{ HP_POP(clif->search_store_info_ack), HP_POP2(HP_clif_search_store_info_ack), 1186 },
+{ HP_POP(clif->search_store_info_failed), HP_POP2(HP_clif_search_store_info_failed), 1188 },
+{ HP_POP(clif->open_search_store_info), HP_POP2(HP_clif_open_search_store_info), 1190 },
+{ HP_POP(clif->search_store_info_click_ack), HP_POP2(HP_clif_search_store_info_click_ack), 1192 },
+{ HP_POP(clif->elemental_info), HP_POP2(HP_clif_elemental_info), 1194 },
+{ HP_POP(clif->elemental_updatestatus), HP_POP2(HP_clif_elemental_updatestatus), 1196 },
+{ HP_POP(clif->bgqueue_ack), HP_POP2(HP_clif_bgqueue_ack), 1198 },
+{ HP_POP(clif->bgqueue_notice_delete), HP_POP2(HP_clif_bgqueue_notice_delete), 1200 },
+{ HP_POP(clif->bgqueue_update_info), HP_POP2(HP_clif_bgqueue_update_info), 1202 },
+{ HP_POP(clif->bgqueue_joined), HP_POP2(HP_clif_bgqueue_joined), 1204 },
+{ HP_POP(clif->bgqueue_pcleft), HP_POP2(HP_clif_bgqueue_pcleft), 1206 },
+{ HP_POP(clif->bgqueue_battlebegins), HP_POP2(HP_clif_bgqueue_battlebegins), 1208 },
+{ HP_POP(clif->adopt_reply), HP_POP2(HP_clif_adopt_reply), 1210 },
+{ HP_POP(clif->adopt_request), HP_POP2(HP_clif_adopt_request), 1212 },
+{ HP_POP(clif->readbook), HP_POP2(HP_clif_readbook), 1214 },
+{ HP_POP(clif->notify_time), HP_POP2(HP_clif_notify_time), 1216 },
+{ HP_POP(clif->user_count), HP_POP2(HP_clif_user_count), 1218 },
+{ HP_POP(clif->noask_sub), HP_POP2(HP_clif_noask_sub), 1220 },
+{ HP_POP(clif->bc_ready), HP_POP2(HP_clif_bc_ready), 1222 },
+{ HP_POP(clif->undisguise_timer), HP_POP2(HP_clif_undisguise_timer), 1224 },
+{ HP_POP(clif->chsys_create), HP_POP2(HP_clif_chsys_create), 1226 },
+{ HP_POP(clif->chsys_msg), HP_POP2(HP_clif_chsys_msg), 1228 },
+{ HP_POP(clif->chsys_msg2), HP_POP2(HP_clif_chsys_msg2), 1230 },
+{ HP_POP(clif->chsys_send), HP_POP2(HP_clif_chsys_send), 1232 },
+{ HP_POP(clif->chsys_join), HP_POP2(HP_clif_chsys_join), 1234 },
+{ HP_POP(clif->chsys_left), HP_POP2(HP_clif_chsys_left), 1236 },
+{ HP_POP(clif->chsys_delete), HP_POP2(HP_clif_chsys_delete), 1238 },
+{ HP_POP(clif->chsys_mjoin), HP_POP2(HP_clif_chsys_mjoin), 1240 },
+{ HP_POP(clif->chsys_quit), HP_POP2(HP_clif_chsys_quit), 1242 },
+{ HP_POP(clif->chsys_quitg), HP_POP2(HP_clif_chsys_quitg), 1244 },
+{ HP_POP(clif->chsys_gjoin), HP_POP2(HP_clif_chsys_gjoin), 1246 },
+{ HP_POP(clif->chsys_gleave), HP_POP2(HP_clif_chsys_gleave), 1248 },
+{ HP_POP(clif->pWantToConnection), HP_POP2(HP_clif_pWantToConnection), 1250 },
+{ HP_POP(clif->pLoadEndAck), HP_POP2(HP_clif_pLoadEndAck), 1252 },
+{ HP_POP(clif->pTickSend), HP_POP2(HP_clif_pTickSend), 1254 },
+{ HP_POP(clif->pHotkey), HP_POP2(HP_clif_pHotkey), 1256 },
+{ HP_POP(clif->pProgressbar), HP_POP2(HP_clif_pProgressbar), 1258 },
+{ HP_POP(clif->pWalkToXY), HP_POP2(HP_clif_pWalkToXY), 1260 },
+{ HP_POP(clif->pQuitGame), HP_POP2(HP_clif_pQuitGame), 1262 },
+{ HP_POP(clif->pGetCharNameRequest), HP_POP2(HP_clif_pGetCharNameRequest), 1264 },
+{ HP_POP(clif->pGlobalMessage), HP_POP2(HP_clif_pGlobalMessage), 1266 },
+{ HP_POP(clif->pMapMove), HP_POP2(HP_clif_pMapMove), 1268 },
+{ HP_POP(clif->pChangeDir), HP_POP2(HP_clif_pChangeDir), 1270 },
+{ HP_POP(clif->pEmotion), HP_POP2(HP_clif_pEmotion), 1272 },
+{ HP_POP(clif->pHowManyConnections), HP_POP2(HP_clif_pHowManyConnections), 1274 },
+{ HP_POP(clif->pActionRequest), HP_POP2(HP_clif_pActionRequest), 1276 },
+{ HP_POP(clif->pActionRequest_sub), HP_POP2(HP_clif_pActionRequest_sub), 1278 },
+{ HP_POP(clif->pRestart), HP_POP2(HP_clif_pRestart), 1280 },
+{ HP_POP(clif->pWisMessage), HP_POP2(HP_clif_pWisMessage), 1282 },
+{ HP_POP(clif->pBroadcast), HP_POP2(HP_clif_pBroadcast), 1284 },
+{ HP_POP(clif->pTakeItem), HP_POP2(HP_clif_pTakeItem), 1286 },
+{ HP_POP(clif->pDropItem), HP_POP2(HP_clif_pDropItem), 1288 },
+{ HP_POP(clif->pUseItem), HP_POP2(HP_clif_pUseItem), 1290 },
+{ HP_POP(clif->pEquipItem), HP_POP2(HP_clif_pEquipItem), 1292 },
+{ HP_POP(clif->pUnequipItem), HP_POP2(HP_clif_pUnequipItem), 1294 },
+{ HP_POP(clif->pNpcClicked), HP_POP2(HP_clif_pNpcClicked), 1296 },
+{ HP_POP(clif->pNpcBuySellSelected), HP_POP2(HP_clif_pNpcBuySellSelected), 1298 },
+{ HP_POP(clif->pNpcBuyListSend), HP_POP2(HP_clif_pNpcBuyListSend), 1300 },
+{ HP_POP(clif->pNpcSellListSend), HP_POP2(HP_clif_pNpcSellListSend), 1302 },
+{ HP_POP(clif->pCreateChatRoom), HP_POP2(HP_clif_pCreateChatRoom), 1304 },
+{ HP_POP(clif->pChatAddMember), HP_POP2(HP_clif_pChatAddMember), 1306 },
+{ HP_POP(clif->pChatRoomStatusChange), HP_POP2(HP_clif_pChatRoomStatusChange), 1308 },
+{ HP_POP(clif->pChangeChatOwner), HP_POP2(HP_clif_pChangeChatOwner), 1310 },
+{ HP_POP(clif->pKickFromChat), HP_POP2(HP_clif_pKickFromChat), 1312 },
+{ HP_POP(clif->pChatLeave), HP_POP2(HP_clif_pChatLeave), 1314 },
+{ HP_POP(clif->pTradeRequest), HP_POP2(HP_clif_pTradeRequest), 1316 },
+{ HP_POP(clif->chann_config_read), HP_POP2(HP_clif_chann_config_read), 1318 },
+{ HP_POP(clif->pTradeAck), HP_POP2(HP_clif_pTradeAck), 1320 },
+{ HP_POP(clif->pTradeAddItem), HP_POP2(HP_clif_pTradeAddItem), 1322 },
+{ HP_POP(clif->pTradeOk), HP_POP2(HP_clif_pTradeOk), 1324 },
+{ HP_POP(clif->pTradeCancel), HP_POP2(HP_clif_pTradeCancel), 1326 },
+{ HP_POP(clif->pTradeCommit), HP_POP2(HP_clif_pTradeCommit), 1328 },
+{ HP_POP(clif->pStopAttack), HP_POP2(HP_clif_pStopAttack), 1330 },
+{ HP_POP(clif->pPutItemToCart), HP_POP2(HP_clif_pPutItemToCart), 1332 },
+{ HP_POP(clif->pGetItemFromCart), HP_POP2(HP_clif_pGetItemFromCart), 1334 },
+{ HP_POP(clif->pRemoveOption), HP_POP2(HP_clif_pRemoveOption), 1336 },
+{ HP_POP(clif->pChangeCart), HP_POP2(HP_clif_pChangeCart), 1338 },
+{ HP_POP(clif->pStatusUp), HP_POP2(HP_clif_pStatusUp), 1340 },
+{ HP_POP(clif->pSkillUp), HP_POP2(HP_clif_pSkillUp), 1342 },
+{ HP_POP(clif->pUseSkillToId), HP_POP2(HP_clif_pUseSkillToId), 1344 },
+{ HP_POP(clif->pUseSkillToId_homun), HP_POP2(HP_clif_pUseSkillToId_homun), 1346 },
+{ HP_POP(clif->pUseSkillToId_mercenary), HP_POP2(HP_clif_pUseSkillToId_mercenary), 1348 },
+{ HP_POP(clif->pUseSkillToPos), HP_POP2(HP_clif_pUseSkillToPos), 1350 },
+{ HP_POP(clif->pUseSkillToPosSub), HP_POP2(HP_clif_pUseSkillToPosSub), 1352 },
+{ HP_POP(clif->pUseSkillToPos_homun), HP_POP2(HP_clif_pUseSkillToPos_homun), 1354 },
+{ HP_POP(clif->pUseSkillToPos_mercenary), HP_POP2(HP_clif_pUseSkillToPos_mercenary), 1356 },
+{ HP_POP(clif->pUseSkillToPosMoreInfo), HP_POP2(HP_clif_pUseSkillToPosMoreInfo), 1358 },
+{ HP_POP(clif->pUseSkillMap), HP_POP2(HP_clif_pUseSkillMap), 1360 },
+{ HP_POP(clif->pRequestMemo), HP_POP2(HP_clif_pRequestMemo), 1362 },
+{ HP_POP(clif->pProduceMix), HP_POP2(HP_clif_pProduceMix), 1364 },
+{ HP_POP(clif->pCooking), HP_POP2(HP_clif_pCooking), 1366 },
+{ HP_POP(clif->pRepairItem), HP_POP2(HP_clif_pRepairItem), 1368 },
+{ HP_POP(clif->pWeaponRefine), HP_POP2(HP_clif_pWeaponRefine), 1370 },
+{ HP_POP(clif->pNpcSelectMenu), HP_POP2(HP_clif_pNpcSelectMenu), 1372 },
+{ HP_POP(clif->pNpcNextClicked), HP_POP2(HP_clif_pNpcNextClicked), 1374 },
+{ HP_POP(clif->pNpcAmountInput), HP_POP2(HP_clif_pNpcAmountInput), 1376 },
+{ HP_POP(clif->pNpcStringInput), HP_POP2(HP_clif_pNpcStringInput), 1378 },
+{ HP_POP(clif->pNpcCloseClicked), HP_POP2(HP_clif_pNpcCloseClicked), 1380 },
+{ HP_POP(clif->pItemIdentify), HP_POP2(HP_clif_pItemIdentify), 1382 },
+{ HP_POP(clif->pSelectArrow), HP_POP2(HP_clif_pSelectArrow), 1384 },
+{ HP_POP(clif->pAutoSpell), HP_POP2(HP_clif_pAutoSpell), 1386 },
+{ HP_POP(clif->pUseCard), HP_POP2(HP_clif_pUseCard), 1388 },
+{ HP_POP(clif->pInsertCard), HP_POP2(HP_clif_pInsertCard), 1390 },
+{ HP_POP(clif->pSolveCharName), HP_POP2(HP_clif_pSolveCharName), 1392 },
+{ HP_POP(clif->pResetChar), HP_POP2(HP_clif_pResetChar), 1394 },
+{ HP_POP(clif->pLocalBroadcast), HP_POP2(HP_clif_pLocalBroadcast), 1396 },
+{ HP_POP(clif->pMoveToKafra), HP_POP2(HP_clif_pMoveToKafra), 1398 },
+{ HP_POP(clif->pMoveFromKafra), HP_POP2(HP_clif_pMoveFromKafra), 1400 },
+{ HP_POP(clif->pMoveToKafraFromCart), HP_POP2(HP_clif_pMoveToKafraFromCart), 1402 },
+{ HP_POP(clif->pMoveFromKafraToCart), HP_POP2(HP_clif_pMoveFromKafraToCart), 1404 },
+{ HP_POP(clif->pCloseKafra), HP_POP2(HP_clif_pCloseKafra), 1406 },
+{ HP_POP(clif->pStoragePassword), HP_POP2(HP_clif_pStoragePassword), 1408 },
+{ HP_POP(clif->pCreateParty), HP_POP2(HP_clif_pCreateParty), 1410 },
+{ HP_POP(clif->pCreateParty2), HP_POP2(HP_clif_pCreateParty2), 1412 },
+{ HP_POP(clif->pPartyInvite), HP_POP2(HP_clif_pPartyInvite), 1414 },
+{ HP_POP(clif->pPartyInvite2), HP_POP2(HP_clif_pPartyInvite2), 1416 },
+{ HP_POP(clif->pReplyPartyInvite), HP_POP2(HP_clif_pReplyPartyInvite), 1418 },
+{ HP_POP(clif->pReplyPartyInvite2), HP_POP2(HP_clif_pReplyPartyInvite2), 1420 },
+{ HP_POP(clif->pLeaveParty), HP_POP2(HP_clif_pLeaveParty), 1422 },
+{ HP_POP(clif->pRemovePartyMember), HP_POP2(HP_clif_pRemovePartyMember), 1424 },
+{ HP_POP(clif->pPartyChangeOption), HP_POP2(HP_clif_pPartyChangeOption), 1426 },
+{ HP_POP(clif->pPartyMessage), HP_POP2(HP_clif_pPartyMessage), 1428 },
+{ HP_POP(clif->pPartyChangeLeader), HP_POP2(HP_clif_pPartyChangeLeader), 1430 },
+{ HP_POP(clif->pPartyBookingRegisterReq), HP_POP2(HP_clif_pPartyBookingRegisterReq), 1432 },
+{ HP_POP(clif->pPartyBookingSearchReq), HP_POP2(HP_clif_pPartyBookingSearchReq), 1434 },
+{ HP_POP(clif->pPartyBookingDeleteReq), HP_POP2(HP_clif_pPartyBookingDeleteReq), 1436 },
+{ HP_POP(clif->pPartyBookingUpdateReq), HP_POP2(HP_clif_pPartyBookingUpdateReq), 1438 },
+{ HP_POP(clif->pCloseVending), HP_POP2(HP_clif_pCloseVending), 1440 },
+{ HP_POP(clif->pVendingListReq), HP_POP2(HP_clif_pVendingListReq), 1442 },
+{ HP_POP(clif->pPurchaseReq), HP_POP2(HP_clif_pPurchaseReq), 1444 },
+{ HP_POP(clif->pPurchaseReq2), HP_POP2(HP_clif_pPurchaseReq2), 1446 },
+{ HP_POP(clif->pOpenVending), HP_POP2(HP_clif_pOpenVending), 1448 },
+{ HP_POP(clif->pCreateGuild), HP_POP2(HP_clif_pCreateGuild), 1450 },
+{ HP_POP(clif->pGuildCheckMaster), HP_POP2(HP_clif_pGuildCheckMaster), 1452 },
+{ HP_POP(clif->pGuildRequestInfo), HP_POP2(HP_clif_pGuildRequestInfo), 1454 },
+{ HP_POP(clif->pGuildChangePositionInfo), HP_POP2(HP_clif_pGuildChangePositionInfo), 1456 },
+{ HP_POP(clif->pGuildChangeMemberPosition), HP_POP2(HP_clif_pGuildChangeMemberPosition), 1458 },
+{ HP_POP(clif->pGuildRequestEmblem), HP_POP2(HP_clif_pGuildRequestEmblem), 1460 },
+{ HP_POP(clif->pGuildChangeEmblem), HP_POP2(HP_clif_pGuildChangeEmblem), 1462 },
+{ HP_POP(clif->pGuildChangeNotice), HP_POP2(HP_clif_pGuildChangeNotice), 1464 },
+{ HP_POP(clif->pGuildInvite), HP_POP2(HP_clif_pGuildInvite), 1466 },
+{ HP_POP(clif->pGuildReplyInvite), HP_POP2(HP_clif_pGuildReplyInvite), 1468 },
+{ HP_POP(clif->pGuildLeave), HP_POP2(HP_clif_pGuildLeave), 1470 },
+{ HP_POP(clif->pGuildExpulsion), HP_POP2(HP_clif_pGuildExpulsion), 1472 },
+{ HP_POP(clif->pGuildMessage), HP_POP2(HP_clif_pGuildMessage), 1474 },
+{ HP_POP(clif->pGuildRequestAlliance), HP_POP2(HP_clif_pGuildRequestAlliance), 1476 },
+{ HP_POP(clif->pGuildReplyAlliance), HP_POP2(HP_clif_pGuildReplyAlliance), 1478 },
+{ HP_POP(clif->pGuildDelAlliance), HP_POP2(HP_clif_pGuildDelAlliance), 1480 },
+{ HP_POP(clif->pGuildOpposition), HP_POP2(HP_clif_pGuildOpposition), 1482 },
+{ HP_POP(clif->pGuildBreak), HP_POP2(HP_clif_pGuildBreak), 1484 },
+{ HP_POP(clif->pPetMenu), HP_POP2(HP_clif_pPetMenu), 1486 },
+{ HP_POP(clif->pCatchPet), HP_POP2(HP_clif_pCatchPet), 1488 },
+{ HP_POP(clif->pSelectEgg), HP_POP2(HP_clif_pSelectEgg), 1490 },
+{ HP_POP(clif->pSendEmotion), HP_POP2(HP_clif_pSendEmotion), 1492 },
+{ HP_POP(clif->pChangePetName), HP_POP2(HP_clif_pChangePetName), 1494 },
+{ HP_POP(clif->pGMKick), HP_POP2(HP_clif_pGMKick), 1496 },
+{ HP_POP(clif->pGMKickAll), HP_POP2(HP_clif_pGMKickAll), 1498 },
+{ HP_POP(clif->pGMShift), HP_POP2(HP_clif_pGMShift), 1500 },
+{ HP_POP(clif->pGMRemove2), HP_POP2(HP_clif_pGMRemove2), 1502 },
+{ HP_POP(clif->pGMRecall), HP_POP2(HP_clif_pGMRecall), 1504 },
+{ HP_POP(clif->pGMRecall2), HP_POP2(HP_clif_pGMRecall2), 1506 },
+{ HP_POP(clif->pGM_Monster_Item), HP_POP2(HP_clif_pGM_Monster_Item), 1508 },
+{ HP_POP(clif->pGMHide), HP_POP2(HP_clif_pGMHide), 1510 },
+{ HP_POP(clif->pGMReqNoChat), HP_POP2(HP_clif_pGMReqNoChat), 1512 },
+{ HP_POP(clif->pGMRc), HP_POP2(HP_clif_pGMRc), 1514 },
+{ HP_POP(clif->pGMReqAccountName), HP_POP2(HP_clif_pGMReqAccountName), 1516 },
+{ HP_POP(clif->pGMChangeMapType), HP_POP2(HP_clif_pGMChangeMapType), 1518 },
+{ HP_POP(clif->pPMIgnore), HP_POP2(HP_clif_pPMIgnore), 1520 },
+{ HP_POP(clif->pPMIgnoreAll), HP_POP2(HP_clif_pPMIgnoreAll), 1522 },
+{ HP_POP(clif->pPMIgnoreList), HP_POP2(HP_clif_pPMIgnoreList), 1524 },
+{ HP_POP(clif->pNoviceDoriDori), HP_POP2(HP_clif_pNoviceDoriDori), 1526 },
+{ HP_POP(clif->pNoviceExplosionSpirits), HP_POP2(HP_clif_pNoviceExplosionSpirits), 1528 },
+{ HP_POP(clif->pFriendsListAdd), HP_POP2(HP_clif_pFriendsListAdd), 1530 },
+{ HP_POP(clif->pFriendsListReply), HP_POP2(HP_clif_pFriendsListReply), 1532 },
+{ HP_POP(clif->pFriendsListRemove), HP_POP2(HP_clif_pFriendsListRemove), 1534 },
+{ HP_POP(clif->pPVPInfo), HP_POP2(HP_clif_pPVPInfo), 1536 },
+{ HP_POP(clif->pBlacksmith), HP_POP2(HP_clif_pBlacksmith), 1538 },
+{ HP_POP(clif->pAlchemist), HP_POP2(HP_clif_pAlchemist), 1540 },
+{ HP_POP(clif->pTaekwon), HP_POP2(HP_clif_pTaekwon), 1542 },
+{ HP_POP(clif->pRankingPk), HP_POP2(HP_clif_pRankingPk), 1544 },
+{ HP_POP(clif->pFeelSaveOk), HP_POP2(HP_clif_pFeelSaveOk), 1546 },
+{ HP_POP(clif->pChangeHomunculusName), HP_POP2(HP_clif_pChangeHomunculusName), 1548 },
+{ HP_POP(clif->pHomMoveToMaster), HP_POP2(HP_clif_pHomMoveToMaster), 1550 },
+{ HP_POP(clif->pHomMoveTo), HP_POP2(HP_clif_pHomMoveTo), 1552 },
+{ HP_POP(clif->pHomAttack), HP_POP2(HP_clif_pHomAttack), 1554 },
+{ HP_POP(clif->pHomMenu), HP_POP2(HP_clif_pHomMenu), 1556 },
+{ HP_POP(clif->pAutoRevive), HP_POP2(HP_clif_pAutoRevive), 1558 },
+{ HP_POP(clif->pCheck), HP_POP2(HP_clif_pCheck), 1560 },
+{ HP_POP(clif->pMail_refreshinbox), HP_POP2(HP_clif_pMail_refreshinbox), 1562 },
+{ HP_POP(clif->pMail_read), HP_POP2(HP_clif_pMail_read), 1564 },
+{ HP_POP(clif->pMail_getattach), HP_POP2(HP_clif_pMail_getattach), 1566 },
+{ HP_POP(clif->pMail_delete), HP_POP2(HP_clif_pMail_delete), 1568 },
+{ HP_POP(clif->pMail_return), HP_POP2(HP_clif_pMail_return), 1570 },
+{ HP_POP(clif->pMail_setattach), HP_POP2(HP_clif_pMail_setattach), 1572 },
+{ HP_POP(clif->pMail_winopen), HP_POP2(HP_clif_pMail_winopen), 1574 },
+{ HP_POP(clif->pMail_send), HP_POP2(HP_clif_pMail_send), 1576 },
+{ HP_POP(clif->pAuction_cancelreg), HP_POP2(HP_clif_pAuction_cancelreg), 1578 },
+{ HP_POP(clif->pAuction_setitem), HP_POP2(HP_clif_pAuction_setitem), 1580 },
+{ HP_POP(clif->pAuction_register), HP_POP2(HP_clif_pAuction_register), 1582 },
+{ HP_POP(clif->pAuction_cancel), HP_POP2(HP_clif_pAuction_cancel), 1584 },
+{ HP_POP(clif->pAuction_close), HP_POP2(HP_clif_pAuction_close), 1586 },
+{ HP_POP(clif->pAuction_bid), HP_POP2(HP_clif_pAuction_bid), 1588 },
+{ HP_POP(clif->pAuction_search), HP_POP2(HP_clif_pAuction_search), 1590 },
+{ HP_POP(clif->pAuction_buysell), HP_POP2(HP_clif_pAuction_buysell), 1592 },
+{ HP_POP(clif->pcashshop_buy), HP_POP2(HP_clif_pcashshop_buy), 1594 },
+{ HP_POP(clif->pAdopt_request), HP_POP2(HP_clif_pAdopt_request), 1596 },
+{ HP_POP(clif->pAdopt_reply), HP_POP2(HP_clif_pAdopt_reply), 1598 },
+{ HP_POP(clif->pViewPlayerEquip), HP_POP2(HP_clif_pViewPlayerEquip), 1600 },
+{ HP_POP(clif->pEquipTick), HP_POP2(HP_clif_pEquipTick), 1602 },
+{ HP_POP(clif->pquestStateAck), HP_POP2(HP_clif_pquestStateAck), 1604 },
+{ HP_POP(clif->pmercenary_action), HP_POP2(HP_clif_pmercenary_action), 1606 },
+{ HP_POP(clif->pBattleChat), HP_POP2(HP_clif_pBattleChat), 1608 },
+{ HP_POP(clif->pLessEffect), HP_POP2(HP_clif_pLessEffect), 1610 },
+{ HP_POP(clif->pItemListWindowSelected), HP_POP2(HP_clif_pItemListWindowSelected), 1612 },
+{ HP_POP(clif->pReqOpenBuyingStore), HP_POP2(HP_clif_pReqOpenBuyingStore), 1614 },
+{ HP_POP(clif->pReqCloseBuyingStore), HP_POP2(HP_clif_pReqCloseBuyingStore), 1616 },
+{ HP_POP(clif->pReqClickBuyingStore), HP_POP2(HP_clif_pReqClickBuyingStore), 1618 },
+{ HP_POP(clif->pReqTradeBuyingStore), HP_POP2(HP_clif_pReqTradeBuyingStore), 1620 },
+{ HP_POP(clif->pSearchStoreInfo), HP_POP2(HP_clif_pSearchStoreInfo), 1622 },
+{ HP_POP(clif->pSearchStoreInfoNextPage), HP_POP2(HP_clif_pSearchStoreInfoNextPage), 1624 },
+{ HP_POP(clif->pCloseSearchStoreInfo), HP_POP2(HP_clif_pCloseSearchStoreInfo), 1626 },
+{ HP_POP(clif->pSearchStoreInfoListItemClick), HP_POP2(HP_clif_pSearchStoreInfoListItemClick), 1628 },
+{ HP_POP(clif->pDebug), HP_POP2(HP_clif_pDebug), 1630 },
+{ HP_POP(clif->pSkillSelectMenu), HP_POP2(HP_clif_pSkillSelectMenu), 1632 },
+{ HP_POP(clif->pMoveItem), HP_POP2(HP_clif_pMoveItem), 1634 },
+{ HP_POP(clif->pDull), HP_POP2(HP_clif_pDull), 1636 },
+{ HP_POP(clif->pBGQueueRegister), HP_POP2(HP_clif_pBGQueueRegister), 1638 },
+{ HP_POP(clif->pBGQueueCheckState), HP_POP2(HP_clif_pBGQueueCheckState), 1640 },
+{ HP_POP(clif->pBGQueueRevokeReq), HP_POP2(HP_clif_pBGQueueRevokeReq), 1642 },
+{ HP_POP(clif->pBGQueueBattleBeginAck), HP_POP2(HP_clif_pBGQueueBattleBeginAck), 1644 },
+{ HP_POP(clif->pCashShopOpen), HP_POP2(HP_clif_pCashShopOpen), 1646 },
+{ HP_POP(clif->pCashShopClose), HP_POP2(HP_clif_pCashShopClose), 1648 },
+{ HP_POP(clif->pCashShopReqTab), HP_POP2(HP_clif_pCashShopReqTab), 1650 },
+{ HP_POP(clif->pCashShopSchedule), HP_POP2(HP_clif_pCashShopSchedule), 1652 },
+{ HP_POP(clif->pCashShopBuy), HP_POP2(HP_clif_pCashShopBuy), 1654 },
+{ HP_POP(clif->pPartyTick), HP_POP2(HP_clif_pPartyTick), 1656 },
+{ HP_POP(clif->pGuildInvite2), HP_POP2(HP_clif_pGuildInvite2), 1658 },
+{ HP_POP(clif->pPartyBookingAddFilter), HP_POP2(HP_clif_pPartyBookingAddFilter), 1660 },
+{ HP_POP(clif->pPartyBookingSubFilter), HP_POP2(HP_clif_pPartyBookingSubFilter), 1662 },
+{ HP_POP(clif->pPartyBookingReqVolunteer), HP_POP2(HP_clif_pPartyBookingReqVolunteer), 1664 },
+{ HP_POP(clif->pPartyBookingRefuseVolunteer), HP_POP2(HP_clif_pPartyBookingRefuseVolunteer), 1666 },
+{ HP_POP(clif->pPartyBookingCancelVolunteer), HP_POP2(HP_clif_pPartyBookingCancelVolunteer), 1668 },
+/* duel */
+{ HP_POP(duel->create), HP_POP2(HP_duel_create), 1670 },
+{ HP_POP(duel->invite), HP_POP2(HP_duel_invite), 1672 },
+{ HP_POP(duel->accept), HP_POP2(HP_duel_accept), 1674 },
+{ HP_POP(duel->reject), HP_POP2(HP_duel_reject), 1676 },
+{ HP_POP(duel->leave), HP_POP2(HP_duel_leave), 1678 },
+{ HP_POP(duel->showinfo), HP_POP2(HP_duel_showinfo), 1680 },
+{ HP_POP(duel->checktime), HP_POP2(HP_duel_checktime), 1682 },
+{ HP_POP(duel->init), HP_POP2(HP_duel_init), 1684 },
+{ HP_POP(duel->final), HP_POP2(HP_duel_final), 1686 },
+/* elemental */
+{ HP_POP(elemental->init), HP_POP2(HP_elemental_init), 1688 },
+{ HP_POP(elemental->final), HP_POP2(HP_elemental_final), 1690 },
+{ HP_POP(elemental->class), HP_POP2(HP_elemental_class), 1692 },
+{ HP_POP(elemental->get_viewdata), HP_POP2(HP_elemental_get_viewdata), 1694 },
+{ HP_POP(elemental->create), HP_POP2(HP_elemental_create), 1696 },
+{ HP_POP(elemental->data_received), HP_POP2(HP_elemental_data_received), 1698 },
+{ HP_POP(elemental->save), HP_POP2(HP_elemental_save), 1700 },
+{ HP_POP(elemental->change_mode_ack), HP_POP2(HP_elemental_change_mode_ack), 1702 },
+{ HP_POP(elemental->change_mode), HP_POP2(HP_elemental_change_mode), 1704 },
+{ HP_POP(elemental->heal), HP_POP2(HP_elemental_heal), 1706 },
+{ HP_POP(elemental->dead), HP_POP2(HP_elemental_dead), 1708 },
+{ HP_POP(elemental->delete), HP_POP2(HP_elemental_delete), 1710 },
+{ HP_POP(elemental->summon_stop), HP_POP2(HP_elemental_summon_stop), 1712 },
+{ HP_POP(elemental->get_lifetime), HP_POP2(HP_elemental_get_lifetime), 1714 },
+{ HP_POP(elemental->unlocktarget), HP_POP2(HP_elemental_unlocktarget), 1716 },
+{ HP_POP(elemental->skillnotok), HP_POP2(HP_elemental_skillnotok), 1718 },
+{ HP_POP(elemental->set_target), HP_POP2(HP_elemental_set_target), 1720 },
+{ HP_POP(elemental->clean_single_effect), HP_POP2(HP_elemental_clean_single_effect), 1722 },
+{ HP_POP(elemental->clean_effect), HP_POP2(HP_elemental_clean_effect), 1724 },
+{ HP_POP(elemental->action), HP_POP2(HP_elemental_action), 1726 },
+{ HP_POP(elemental->skill_get_requirements), HP_POP2(HP_elemental_skill_get_requirements), 1728 },
+{ HP_POP(elemental->read_skilldb), HP_POP2(HP_elemental_read_skilldb), 1730 },
+{ HP_POP(elemental->reload_db), HP_POP2(HP_elemental_reload_db), 1732 },
+{ HP_POP(elemental->reload_skilldb), HP_POP2(HP_elemental_reload_skilldb), 1734 },
+{ HP_POP(elemental->search_index), HP_POP2(HP_elemental_search_index), 1736 },
+{ HP_POP(elemental->summon_init), HP_POP2(HP_elemental_summon_init), 1738 },
+{ HP_POP(elemental->summon_end_timer), HP_POP2(HP_elemental_summon_end_timer), 1740 },
+{ HP_POP(elemental->ai_sub_timer_activesearch), HP_POP2(HP_elemental_ai_sub_timer_activesearch), 1742 },
+{ HP_POP(elemental->ai_sub_timer), HP_POP2(HP_elemental_ai_sub_timer), 1744 },
+{ HP_POP(elemental->ai_sub_foreachclient), HP_POP2(HP_elemental_ai_sub_foreachclient), 1746 },
+{ HP_POP(elemental->ai_timer), HP_POP2(HP_elemental_ai_timer), 1748 },
+{ HP_POP(elemental->read_db), HP_POP2(HP_elemental_read_db), 1750 },
+/* guild */
+{ HP_POP(guild->init), HP_POP2(HP_guild_init), 1752 },
+{ HP_POP(guild->final), HP_POP2(HP_guild_final), 1754 },
+{ HP_POP(guild->skill_get_max), HP_POP2(HP_guild_skill_get_max), 1756 },
+{ HP_POP(guild->checkskill), HP_POP2(HP_guild_checkskill), 1758 },
+{ HP_POP(guild->check_skill_require), HP_POP2(HP_guild_check_skill_require), 1760 },
+{ HP_POP(guild->checkcastles), HP_POP2(HP_guild_checkcastles), 1762 },
+{ HP_POP(guild->isallied), HP_POP2(HP_guild_isallied), 1764 },
+{ HP_POP(guild->search), HP_POP2(HP_guild_search), 1766 },
+{ HP_POP(guild->searchname), HP_POP2(HP_guild_searchname), 1768 },
+{ HP_POP(guild->castle_search), HP_POP2(HP_guild_castle_search), 1770 },
+{ HP_POP(guild->mapname2gc), HP_POP2(HP_guild_mapname2gc), 1772 },
+{ HP_POP(guild->mapindex2gc), HP_POP2(HP_guild_mapindex2gc), 1774 },
+{ HP_POP(guild->getavailablesd), HP_POP2(HP_guild_getavailablesd), 1776 },
+{ HP_POP(guild->getindex), HP_POP2(HP_guild_getindex), 1778 },
+{ HP_POP(guild->getposition), HP_POP2(HP_guild_getposition), 1780 },
+{ HP_POP(guild->payexp), HP_POP2(HP_guild_payexp), 1782 },
+{ HP_POP(guild->getexp), HP_POP2(HP_guild_getexp), 1784 },
+{ HP_POP(guild->create), HP_POP2(HP_guild_create), 1786 },
+{ HP_POP(guild->created), HP_POP2(HP_guild_created), 1788 },
+{ HP_POP(guild->request_info), HP_POP2(HP_guild_request_info), 1790 },
+{ HP_POP(guild->recv_noinfo), HP_POP2(HP_guild_recv_noinfo), 1792 },
+{ HP_POP(guild->recv_info), HP_POP2(HP_guild_recv_info), 1794 },
+{ HP_POP(guild->npc_request_info), HP_POP2(HP_guild_npc_request_info), 1796 },
+{ HP_POP(guild->invite), HP_POP2(HP_guild_invite), 1798 },
+{ HP_POP(guild->reply_invite), HP_POP2(HP_guild_reply_invite), 1800 },
+{ HP_POP(guild->member_joined), HP_POP2(HP_guild_member_joined), 1802 },
+{ HP_POP(guild->member_added), HP_POP2(HP_guild_member_added), 1804 },
+{ HP_POP(guild->leave), HP_POP2(HP_guild_leave), 1806 },
+{ HP_POP(guild->member_withdraw), HP_POP2(HP_guild_member_withdraw), 1808 },
+{ HP_POP(guild->expulsion), HP_POP2(HP_guild_expulsion), 1810 },
+{ HP_POP(guild->skillup), HP_POP2(HP_guild_skillup), 1812 },
+{ HP_POP(guild->block_skill), HP_POP2(HP_guild_block_skill), 1814 },
+{ HP_POP(guild->reqalliance), HP_POP2(HP_guild_reqalliance), 1816 },
+{ HP_POP(guild->reply_reqalliance), HP_POP2(HP_guild_reply_reqalliance), 1818 },
+{ HP_POP(guild->allianceack), HP_POP2(HP_guild_allianceack), 1820 },
+{ HP_POP(guild->delalliance), HP_POP2(HP_guild_delalliance), 1822 },
+{ HP_POP(guild->opposition), HP_POP2(HP_guild_opposition), 1824 },
+{ HP_POP(guild->check_alliance), HP_POP2(HP_guild_check_alliance), 1826 },
+{ HP_POP(guild->send_memberinfoshort), HP_POP2(HP_guild_send_memberinfoshort), 1828 },
+{ HP_POP(guild->recv_memberinfoshort), HP_POP2(HP_guild_recv_memberinfoshort), 1830 },
+{ HP_POP(guild->change_memberposition), HP_POP2(HP_guild_change_memberposition), 1832 },
+{ HP_POP(guild->memberposition_changed), HP_POP2(HP_guild_memberposition_changed), 1834 },
+{ HP_POP(guild->change_position), HP_POP2(HP_guild_change_position), 1836 },
+{ HP_POP(guild->position_changed), HP_POP2(HP_guild_position_changed), 1838 },
+{ HP_POP(guild->change_notice), HP_POP2(HP_guild_change_notice), 1840 },
+{ HP_POP(guild->notice_changed), HP_POP2(HP_guild_notice_changed), 1842 },
+{ HP_POP(guild->change_emblem), HP_POP2(HP_guild_change_emblem), 1844 },
+{ HP_POP(guild->emblem_changed), HP_POP2(HP_guild_emblem_changed), 1846 },
+{ HP_POP(guild->send_message), HP_POP2(HP_guild_send_message), 1848 },
+{ HP_POP(guild->recv_message), HP_POP2(HP_guild_recv_message), 1850 },
+{ HP_POP(guild->send_dot_remove), HP_POP2(HP_guild_send_dot_remove), 1852 },
+{ HP_POP(guild->skillupack), HP_POP2(HP_guild_skillupack), 1854 },
+{ HP_POP(guild->dobreak), HP_POP2(HP_guild_dobreak), 1856 },
+{ HP_POP(guild->broken), HP_POP2(HP_guild_broken), 1858 },
+{ HP_POP(guild->gm_change), HP_POP2(HP_guild_gm_change), 1860 },
+{ HP_POP(guild->gm_changed), HP_POP2(HP_guild_gm_changed), 1862 },
+{ HP_POP(guild->castle_map_init), HP_POP2(HP_guild_castle_map_init), 1864 },
+{ HP_POP(guild->castledatasave), HP_POP2(HP_guild_castledatasave), 1866 },
+{ HP_POP(guild->castledataloadack), HP_POP2(HP_guild_castledataloadack), 1868 },
+{ HP_POP(guild->castle_reconnect), HP_POP2(HP_guild_castle_reconnect), 1870 },
+{ HP_POP(guild->agit_start), HP_POP2(HP_guild_agit_start), 1872 },
+{ HP_POP(guild->agit_end), HP_POP2(HP_guild_agit_end), 1874 },
+{ HP_POP(guild->agit2_start), HP_POP2(HP_guild_agit2_start), 1876 },
+{ HP_POP(guild->agit2_end), HP_POP2(HP_guild_agit2_end), 1878 },
+{ HP_POP(guild->flag_add), HP_POP2(HP_guild_flag_add), 1880 },
+{ HP_POP(guild->flag_remove), HP_POP2(HP_guild_flag_remove), 1882 },
+{ HP_POP(guild->flags_clear), HP_POP2(HP_guild_flags_clear), 1884 },
+{ HP_POP(guild->aura_refresh), HP_POP2(HP_guild_aura_refresh), 1886 },
+{ HP_POP(guild->payexp_timer), HP_POP2(HP_guild_payexp_timer), 1888 },
+{ HP_POP(guild->sd_check), HP_POP2(HP_guild_sd_check), 1890 },
+{ HP_POP(guild->read_guildskill_tree_db), HP_POP2(HP_guild_read_guildskill_tree_db), 1892 },
+{ HP_POP(guild->read_castledb), HP_POP2(HP_guild_read_castledb), 1894 },
+{ HP_POP(guild->payexp_timer_sub), HP_POP2(HP_guild_payexp_timer_sub), 1896 },
+{ HP_POP(guild->send_xy_timer_sub), HP_POP2(HP_guild_send_xy_timer_sub), 1898 },
+{ HP_POP(guild->send_xy_timer), HP_POP2(HP_guild_send_xy_timer), 1900 },
+{ HP_POP(guild->create_expcache), HP_POP2(HP_guild_create_expcache), 1902 },
+{ HP_POP(guild->eventlist_db_final), HP_POP2(HP_guild_eventlist_db_final), 1904 },
+{ HP_POP(guild->expcache_db_final), HP_POP2(HP_guild_expcache_db_final), 1906 },
+{ HP_POP(guild->castle_db_final), HP_POP2(HP_guild_castle_db_final), 1908 },
+{ HP_POP(guild->broken_sub), HP_POP2(HP_guild_broken_sub), 1910 },
+{ HP_POP(guild->castle_broken_sub), HP_POP2(HP_guild_castle_broken_sub), 1912 },
+{ HP_POP(guild->makemember), HP_POP2(HP_guild_makemember), 1914 },
+{ HP_POP(guild->check_member), HP_POP2(HP_guild_check_member), 1916 },
+{ HP_POP(guild->get_alliance_count), HP_POP2(HP_guild_get_alliance_count), 1918 },
+{ HP_POP(guild->castle_reconnect_sub), HP_POP2(HP_guild_castle_reconnect_sub), 1920 },
+/* gstorage */
+{ HP_POP(gstorage->id2storage), HP_POP2(HP_gstorage_id2storage), 1922 },
+{ HP_POP(gstorage->id2storage2), HP_POP2(HP_gstorage_id2storage2), 1924 },
+{ HP_POP(gstorage->init), HP_POP2(HP_gstorage_init), 1926 },
+{ HP_POP(gstorage->final), HP_POP2(HP_gstorage_final), 1928 },
+{ HP_POP(gstorage->delete), HP_POP2(HP_gstorage_delete), 1930 },
+{ HP_POP(gstorage->open), HP_POP2(HP_gstorage_open), 1932 },
+{ HP_POP(gstorage->additem), HP_POP2(HP_gstorage_additem), 1934 },
+{ HP_POP(gstorage->delitem), HP_POP2(HP_gstorage_delitem), 1936 },
+{ HP_POP(gstorage->add), HP_POP2(HP_gstorage_add), 1938 },
+{ HP_POP(gstorage->get), HP_POP2(HP_gstorage_get), 1940 },
+{ HP_POP(gstorage->addfromcart), HP_POP2(HP_gstorage_addfromcart), 1942 },
+{ HP_POP(gstorage->gettocart), HP_POP2(HP_gstorage_gettocart), 1944 },
+{ HP_POP(gstorage->close), HP_POP2(HP_gstorage_close), 1946 },
+{ HP_POP(gstorage->pc_quit), HP_POP2(HP_gstorage_pc_quit), 1948 },
+{ HP_POP(gstorage->save), HP_POP2(HP_gstorage_save), 1950 },
+{ HP_POP(gstorage->saved), HP_POP2(HP_gstorage_saved), 1952 },
+{ HP_POP(gstorage->create), HP_POP2(HP_gstorage_create), 1954 },
+/* homun */
+{ HP_POP(homun->init), HP_POP2(HP_homun_init), 1956 },
+{ HP_POP(homun->final), HP_POP2(HP_homun_final), 1958 },
+{ HP_POP(homun->reload), HP_POP2(HP_homun_reload), 1960 },
+{ HP_POP(homun->reload_skill), HP_POP2(HP_homun_reload_skill), 1962 },
+{ HP_POP(homun->get_viewdata), HP_POP2(HP_homun_get_viewdata), 1964 },
+{ HP_POP(homun->class2type), HP_POP2(HP_homun_class2type), 1966 },
+{ HP_POP(homun->damaged), HP_POP2(HP_homun_damaged), 1968 },
+{ HP_POP(homun->dead), HP_POP2(HP_homun_dead), 1970 },
+{ HP_POP(homun->vaporize), HP_POP2(HP_homun_vaporize), 1972 },
+{ HP_POP(homun->delete), HP_POP2(HP_homun_delete), 1974 },
+{ HP_POP(homun->checkskill), HP_POP2(HP_homun_checkskill), 1976 },
+{ HP_POP(homun->calc_skilltree), HP_POP2(HP_homun_calc_skilltree), 1978 },
+{ HP_POP(homun->skill_tree_get_max), HP_POP2(HP_homun_skill_tree_get_max), 1980 },
+{ HP_POP(homun->skillup), HP_POP2(HP_homun_skillup), 1982 },
+{ HP_POP(homun->levelup), HP_POP2(HP_homun_levelup), 1984 },
+{ HP_POP(homun->change_class), HP_POP2(HP_homun_change_class), 1986 },
+{ HP_POP(homun->evolve), HP_POP2(HP_homun_evolve), 1988 },
+{ HP_POP(homun->mutate), HP_POP2(HP_homun_mutate), 1990 },
+{ HP_POP(homun->gainexp), HP_POP2(HP_homun_gainexp), 1992 },
+{ HP_POP(homun->add_intimacy), HP_POP2(HP_homun_add_intimacy), 1994 },
+{ HP_POP(homun->consume_intimacy), HP_POP2(HP_homun_consume_intimacy), 1996 },
+{ HP_POP(homun->healed), HP_POP2(HP_homun_healed), 1998 },
+{ HP_POP(homun->save), HP_POP2(HP_homun_save), 2000 },
+{ HP_POP(homun->menu), HP_POP2(HP_homun_menu), 2002 },
+{ HP_POP(homun->feed), HP_POP2(HP_homun_feed), 2004 },
+{ HP_POP(homun->hunger_timer), HP_POP2(HP_homun_hunger_timer), 2006 },
+{ HP_POP(homun->hunger_timer_delete), HP_POP2(HP_homun_hunger_timer_delete), 2008 },
+{ HP_POP(homun->change_name), HP_POP2(HP_homun_change_name), 2010 },
+{ HP_POP(homun->change_name_ack), HP_POP2(HP_homun_change_name_ack), 2012 },
+{ HP_POP(homun->db_search), HP_POP2(HP_homun_db_search), 2014 },
+{ HP_POP(homun->create), HP_POP2(HP_homun_create), 2016 },
+{ HP_POP(homun->init_timers), HP_POP2(HP_homun_init_timers), 2018 },
+{ HP_POP(homun->call), HP_POP2(HP_homun_call), 2020 },
+{ HP_POP(homun->recv_data), HP_POP2(HP_homun_recv_data), 2022 },
+{ HP_POP(homun->creation_request), HP_POP2(HP_homun_creation_request), 2024 },
+{ HP_POP(homun->ressurect), HP_POP2(HP_homun_ressurect), 2026 },
+{ HP_POP(homun->revive), HP_POP2(HP_homun_revive), 2028 },
+{ HP_POP(homun->stat_reset), HP_POP2(HP_homun_stat_reset), 2030 },
+{ HP_POP(homun->shuffle), HP_POP2(HP_homun_shuffle), 2032 },
+{ HP_POP(homun->read_db_sub), HP_POP2(HP_homun_read_db_sub), 2034 },
+{ HP_POP(homun->read_db), HP_POP2(HP_homun_read_db), 2036 },
+{ HP_POP(homun->read_skill_db_sub), HP_POP2(HP_homun_read_skill_db_sub), 2038 },
+{ HP_POP(homun->skill_db_read), HP_POP2(HP_homun_skill_db_read), 2040 },
+{ HP_POP(homun->exp_db_read), HP_POP2(HP_homun_exp_db_read), 2042 },
+{ HP_POP(homun->addspiritball), HP_POP2(HP_homun_addspiritball), 2044 },
+{ HP_POP(homun->delspiritball), HP_POP2(HP_homun_delspiritball), 2046 },
+/* instance */
+{ HP_POP(instance->init), HP_POP2(HP_instance_init), 2048 },
+{ HP_POP(instance->final), HP_POP2(HP_instance_final), 2050 },
+{ HP_POP(instance->create), HP_POP2(HP_instance_create), 2052 },
+{ HP_POP(instance->add_map), HP_POP2(HP_instance_add_map), 2054 },
+{ HP_POP(instance->del_map), HP_POP2(HP_instance_del_map), 2056 },
+{ HP_POP(instance->map2imap), HP_POP2(HP_instance_map2imap), 2058 },
+{ HP_POP(instance->mapid2imapid), HP_POP2(HP_instance_mapid2imapid), 2060 },
+{ HP_POP(instance->destroy), HP_POP2(HP_instance_destroy), 2062 },
+{ HP_POP(instance->start), HP_POP2(HP_instance_start), 2064 },
+{ HP_POP(instance->check_idle), HP_POP2(HP_instance_check_idle), 2066 },
+{ HP_POP(instance->check_kick), HP_POP2(HP_instance_check_kick), 2068 },
+{ HP_POP(instance->set_timeout), HP_POP2(HP_instance_set_timeout), 2070 },
+{ HP_POP(instance->valid), HP_POP2(HP_instance_valid), 2072 },
+{ HP_POP(instance->destroy_timer), HP_POP2(HP_instance_destroy_timer), 2074 },
+/* intif */
+{ HP_POP(intif->parse), HP_POP2(HP_intif_parse), 2076 },
+{ HP_POP(intif->create_pet), HP_POP2(HP_intif_create_pet), 2078 },
+{ HP_POP(intif->broadcast), HP_POP2(HP_intif_broadcast), 2080 },
+{ HP_POP(intif->broadcast2), HP_POP2(HP_intif_broadcast2), 2082 },
+{ HP_POP(intif->main_message), HP_POP2(HP_intif_main_message), 2084 },
+{ HP_POP(intif->wis_message), HP_POP2(HP_intif_wis_message), 2086 },
+{ HP_POP(intif->wis_message_to_gm), HP_POP2(HP_intif_wis_message_to_gm), 2088 },
+{ HP_POP(intif->saveregistry), HP_POP2(HP_intif_saveregistry), 2090 },
+{ HP_POP(intif->request_registry), HP_POP2(HP_intif_request_registry), 2092 },
+{ HP_POP(intif->request_guild_storage), HP_POP2(HP_intif_request_guild_storage), 2094 },
+{ HP_POP(intif->send_guild_storage), HP_POP2(HP_intif_send_guild_storage), 2096 },
+{ HP_POP(intif->create_party), HP_POP2(HP_intif_create_party), 2098 },
+{ HP_POP(intif->request_partyinfo), HP_POP2(HP_intif_request_partyinfo), 2100 },
+{ HP_POP(intif->party_addmember), HP_POP2(HP_intif_party_addmember), 2102 },
+{ HP_POP(intif->party_changeoption), HP_POP2(HP_intif_party_changeoption), 2104 },
+{ HP_POP(intif->party_leave), HP_POP2(HP_intif_party_leave), 2106 },
+{ HP_POP(intif->party_changemap), HP_POP2(HP_intif_party_changemap), 2108 },
+{ HP_POP(intif->break_party), HP_POP2(HP_intif_break_party), 2110 },
+{ HP_POP(intif->party_message), HP_POP2(HP_intif_party_message), 2112 },
+{ HP_POP(intif->party_leaderchange), HP_POP2(HP_intif_party_leaderchange), 2114 },
+{ HP_POP(intif->guild_create), HP_POP2(HP_intif_guild_create), 2116 },
+{ HP_POP(intif->guild_request_info), HP_POP2(HP_intif_guild_request_info), 2118 },
+{ HP_POP(intif->guild_addmember), HP_POP2(HP_intif_guild_addmember), 2120 },
+{ HP_POP(intif->guild_leave), HP_POP2(HP_intif_guild_leave), 2122 },
+{ HP_POP(intif->guild_memberinfoshort), HP_POP2(HP_intif_guild_memberinfoshort), 2124 },
+{ HP_POP(intif->guild_break), HP_POP2(HP_intif_guild_break), 2126 },
+{ HP_POP(intif->guild_message), HP_POP2(HP_intif_guild_message), 2128 },
+{ HP_POP(intif->guild_change_gm), HP_POP2(HP_intif_guild_change_gm), 2130 },
+{ HP_POP(intif->guild_change_basicinfo), HP_POP2(HP_intif_guild_change_basicinfo), 2132 },
+{ HP_POP(intif->guild_change_memberinfo), HP_POP2(HP_intif_guild_change_memberinfo), 2134 },
+{ HP_POP(intif->guild_position), HP_POP2(HP_intif_guild_position), 2136 },
+{ HP_POP(intif->guild_skillup), HP_POP2(HP_intif_guild_skillup), 2138 },
+{ HP_POP(intif->guild_alliance), HP_POP2(HP_intif_guild_alliance), 2140 },
+{ HP_POP(intif->guild_notice), HP_POP2(HP_intif_guild_notice), 2142 },
+{ HP_POP(intif->guild_emblem), HP_POP2(HP_intif_guild_emblem), 2144 },
+{ HP_POP(intif->guild_castle_dataload), HP_POP2(HP_intif_guild_castle_dataload), 2146 },
+{ HP_POP(intif->guild_castle_datasave), HP_POP2(HP_intif_guild_castle_datasave), 2148 },
+{ HP_POP(intif->request_petdata), HP_POP2(HP_intif_request_petdata), 2150 },
+{ HP_POP(intif->save_petdata), HP_POP2(HP_intif_save_petdata), 2152 },
+{ HP_POP(intif->delete_petdata), HP_POP2(HP_intif_delete_petdata), 2154 },
+{ HP_POP(intif->rename), HP_POP2(HP_intif_rename), 2156 },
+{ HP_POP(intif->homunculus_create), HP_POP2(HP_intif_homunculus_create), 2158 },
+{ HP_POP(intif->homunculus_requestload), HP_POP2(HP_intif_homunculus_requestload), 2160 },
+{ HP_POP(intif->homunculus_requestsave), HP_POP2(HP_intif_homunculus_requestsave), 2162 },
+{ HP_POP(intif->homunculus_requestdelete), HP_POP2(HP_intif_homunculus_requestdelete), 2164 },
+{ HP_POP(intif->request_questlog), HP_POP2(HP_intif_request_questlog), 2166 },
+{ HP_POP(intif->quest_save), HP_POP2(HP_intif_quest_save), 2168 },
+{ HP_POP(intif->mercenary_create), HP_POP2(HP_intif_mercenary_create), 2170 },
+{ HP_POP(intif->mercenary_request), HP_POP2(HP_intif_mercenary_request), 2172 },
+{ HP_POP(intif->mercenary_delete), HP_POP2(HP_intif_mercenary_delete), 2174 },
+{ HP_POP(intif->mercenary_save), HP_POP2(HP_intif_mercenary_save), 2176 },
+{ HP_POP(intif->Mail_requestinbox), HP_POP2(HP_intif_Mail_requestinbox), 2178 },
+{ HP_POP(intif->Mail_read), HP_POP2(HP_intif_Mail_read), 2180 },
+{ HP_POP(intif->Mail_getattach), HP_POP2(HP_intif_Mail_getattach), 2182 },
+{ HP_POP(intif->Mail_delete), HP_POP2(HP_intif_Mail_delete), 2184 },
+{ HP_POP(intif->Mail_return), HP_POP2(HP_intif_Mail_return), 2186 },
+{ HP_POP(intif->Mail_send), HP_POP2(HP_intif_Mail_send), 2188 },
+{ HP_POP(intif->Auction_requestlist), HP_POP2(HP_intif_Auction_requestlist), 2190 },
+{ HP_POP(intif->Auction_register), HP_POP2(HP_intif_Auction_register), 2192 },
+{ HP_POP(intif->Auction_cancel), HP_POP2(HP_intif_Auction_cancel), 2194 },
+{ HP_POP(intif->Auction_close), HP_POP2(HP_intif_Auction_close), 2196 },
+{ HP_POP(intif->Auction_bid), HP_POP2(HP_intif_Auction_bid), 2198 },
+{ HP_POP(intif->elemental_create), HP_POP2(HP_intif_elemental_create), 2200 },
+{ HP_POP(intif->elemental_request), HP_POP2(HP_intif_elemental_request), 2202 },
+{ HP_POP(intif->elemental_delete), HP_POP2(HP_intif_elemental_delete), 2204 },
+{ HP_POP(intif->elemental_save), HP_POP2(HP_intif_elemental_save), 2206 },
+{ HP_POP(intif->request_accinfo), HP_POP2(HP_intif_request_accinfo), 2208 },
+{ HP_POP(intif->CheckForCharServer), HP_POP2(HP_intif_CheckForCharServer), 2210 },
+{ HP_POP(intif->pWisMessage), HP_POP2(HP_intif_pWisMessage), 2212 },
+{ HP_POP(intif->pWisEnd), HP_POP2(HP_intif_pWisEnd), 2214 },
+{ HP_POP(intif->pWisToGM_sub), HP_POP2(HP_intif_pWisToGM_sub), 2216 },
+{ HP_POP(intif->pWisToGM), HP_POP2(HP_intif_pWisToGM), 2218 },
+{ HP_POP(intif->pRegisters), HP_POP2(HP_intif_pRegisters), 2220 },
+{ HP_POP(intif->pChangeNameOk), HP_POP2(HP_intif_pChangeNameOk), 2222 },
+{ HP_POP(intif->pMessageToFD), HP_POP2(HP_intif_pMessageToFD), 2224 },
+{ HP_POP(intif->pLoadGuildStorage), HP_POP2(HP_intif_pLoadGuildStorage), 2226 },
+{ HP_POP(intif->pSaveGuildStorage), HP_POP2(HP_intif_pSaveGuildStorage), 2228 },
+{ HP_POP(intif->pPartyCreated), HP_POP2(HP_intif_pPartyCreated), 2230 },
+{ HP_POP(intif->pPartyInfo), HP_POP2(HP_intif_pPartyInfo), 2232 },
+{ HP_POP(intif->pPartyMemberAdded), HP_POP2(HP_intif_pPartyMemberAdded), 2234 },
+{ HP_POP(intif->pPartyOptionChanged), HP_POP2(HP_intif_pPartyOptionChanged), 2236 },
+{ HP_POP(intif->pPartyMemberWithdraw), HP_POP2(HP_intif_pPartyMemberWithdraw), 2238 },
+{ HP_POP(intif->pPartyMove), HP_POP2(HP_intif_pPartyMove), 2240 },
+{ HP_POP(intif->pPartyBroken), HP_POP2(HP_intif_pPartyBroken), 2242 },
+{ HP_POP(intif->pPartyMessage), HP_POP2(HP_intif_pPartyMessage), 2244 },
+{ HP_POP(intif->pGuildCreated), HP_POP2(HP_intif_pGuildCreated), 2246 },
+{ HP_POP(intif->pGuildInfo), HP_POP2(HP_intif_pGuildInfo), 2248 },
+{ HP_POP(intif->pGuildMemberAdded), HP_POP2(HP_intif_pGuildMemberAdded), 2250 },
+{ HP_POP(intif->pGuildMemberWithdraw), HP_POP2(HP_intif_pGuildMemberWithdraw), 2252 },
+{ HP_POP(intif->pGuildMemberInfoShort), HP_POP2(HP_intif_pGuildMemberInfoShort), 2254 },
+{ HP_POP(intif->pGuildBroken), HP_POP2(HP_intif_pGuildBroken), 2256 },
+{ HP_POP(intif->pGuildMessage), HP_POP2(HP_intif_pGuildMessage), 2258 },
+{ HP_POP(intif->pGuildBasicInfoChanged), HP_POP2(HP_intif_pGuildBasicInfoChanged), 2260 },
+{ HP_POP(intif->pGuildMemberInfoChanged), HP_POP2(HP_intif_pGuildMemberInfoChanged), 2262 },
+{ HP_POP(intif->pGuildPosition), HP_POP2(HP_intif_pGuildPosition), 2264 },
+{ HP_POP(intif->pGuildSkillUp), HP_POP2(HP_intif_pGuildSkillUp), 2266 },
+{ HP_POP(intif->pGuildAlliance), HP_POP2(HP_intif_pGuildAlliance), 2268 },
+{ HP_POP(intif->pGuildNotice), HP_POP2(HP_intif_pGuildNotice), 2270 },
+{ HP_POP(intif->pGuildEmblem), HP_POP2(HP_intif_pGuildEmblem), 2272 },
+{ HP_POP(intif->pGuildCastleDataLoad), HP_POP2(HP_intif_pGuildCastleDataLoad), 2274 },
+{ HP_POP(intif->pGuildMasterChanged), HP_POP2(HP_intif_pGuildMasterChanged), 2276 },
+{ HP_POP(intif->pQuestLog), HP_POP2(HP_intif_pQuestLog), 2278 },
+{ HP_POP(intif->pQuestSave), HP_POP2(HP_intif_pQuestSave), 2280 },
+{ HP_POP(intif->pMailInboxReceived), HP_POP2(HP_intif_pMailInboxReceived), 2282 },
+{ HP_POP(intif->pMailNew), HP_POP2(HP_intif_pMailNew), 2284 },
+{ HP_POP(intif->pMailGetAttach), HP_POP2(HP_intif_pMailGetAttach), 2286 },
+{ HP_POP(intif->pMailDelete), HP_POP2(HP_intif_pMailDelete), 2288 },
+{ HP_POP(intif->pMailReturn), HP_POP2(HP_intif_pMailReturn), 2290 },
+{ HP_POP(intif->pMailSend), HP_POP2(HP_intif_pMailSend), 2292 },
+{ HP_POP(intif->pAuctionResults), HP_POP2(HP_intif_pAuctionResults), 2294 },
+{ HP_POP(intif->pAuctionRegister), HP_POP2(HP_intif_pAuctionRegister), 2296 },
+{ HP_POP(intif->pAuctionCancel), HP_POP2(HP_intif_pAuctionCancel), 2298 },
+{ HP_POP(intif->pAuctionClose), HP_POP2(HP_intif_pAuctionClose), 2300 },
+{ HP_POP(intif->pAuctionMessage), HP_POP2(HP_intif_pAuctionMessage), 2302 },
+{ HP_POP(intif->pAuctionBid), HP_POP2(HP_intif_pAuctionBid), 2304 },
+{ HP_POP(intif->pMercenaryReceived), HP_POP2(HP_intif_pMercenaryReceived), 2306 },
+{ HP_POP(intif->pMercenaryDeleted), HP_POP2(HP_intif_pMercenaryDeleted), 2308 },
+{ HP_POP(intif->pMercenarySaved), HP_POP2(HP_intif_pMercenarySaved), 2310 },
+{ HP_POP(intif->pElementalReceived), HP_POP2(HP_intif_pElementalReceived), 2312 },
+{ HP_POP(intif->pElementalDeleted), HP_POP2(HP_intif_pElementalDeleted), 2314 },
+{ HP_POP(intif->pElementalSaved), HP_POP2(HP_intif_pElementalSaved), 2316 },
+{ HP_POP(intif->pCreatePet), HP_POP2(HP_intif_pCreatePet), 2318 },
+{ HP_POP(intif->pRecvPetData), HP_POP2(HP_intif_pRecvPetData), 2320 },
+{ HP_POP(intif->pSavePetOk), HP_POP2(HP_intif_pSavePetOk), 2322 },
+{ HP_POP(intif->pDeletePetOk), HP_POP2(HP_intif_pDeletePetOk), 2324 },
+{ HP_POP(intif->pCreateHomunculus), HP_POP2(HP_intif_pCreateHomunculus), 2326 },
+{ HP_POP(intif->pRecvHomunculusData), HP_POP2(HP_intif_pRecvHomunculusData), 2328 },
+{ HP_POP(intif->pSaveHomunculusOk), HP_POP2(HP_intif_pSaveHomunculusOk), 2330 },
+{ HP_POP(intif->pDeleteHomunculusOk), HP_POP2(HP_intif_pDeleteHomunculusOk), 2332 },
+/* ircbot */
+{ HP_POP(ircbot->init), HP_POP2(HP_ircbot_init), 2334 },
+{ HP_POP(ircbot->final), HP_POP2(HP_ircbot_final), 2336 },
+{ HP_POP(ircbot->parse), HP_POP2(HP_ircbot_parse), 2338 },
+{ HP_POP(ircbot->parse_sub), HP_POP2(HP_ircbot_parse_sub), 2340 },
+{ HP_POP(ircbot->parse_source), HP_POP2(HP_ircbot_parse_source), 2342 },
+{ HP_POP(ircbot->func_search), HP_POP2(HP_ircbot_func_search), 2344 },
+{ HP_POP(ircbot->connect_timer), HP_POP2(HP_ircbot_connect_timer), 2346 },
+{ HP_POP(ircbot->identify_timer), HP_POP2(HP_ircbot_identify_timer), 2348 },
+{ HP_POP(ircbot->join_timer), HP_POP2(HP_ircbot_join_timer), 2350 },
+{ HP_POP(ircbot->send), HP_POP2(HP_ircbot_send), 2352 },
+{ HP_POP(ircbot->relay), HP_POP2(HP_ircbot_relay), 2354 },
+{ HP_POP(ircbot->pong), HP_POP2(HP_ircbot_pong), 2356 },
+{ HP_POP(ircbot->privmsg), HP_POP2(HP_ircbot_privmsg), 2358 },
+{ HP_POP(ircbot->userjoin), HP_POP2(HP_ircbot_userjoin), 2360 },
+{ HP_POP(ircbot->userleave), HP_POP2(HP_ircbot_userleave), 2362 },
+{ HP_POP(ircbot->usernick), HP_POP2(HP_ircbot_usernick), 2364 },
+/* itemdb */
+{ HP_POP(itemdb->init), HP_POP2(HP_itemdb_init), 2366 },
+{ HP_POP(itemdb->final), HP_POP2(HP_itemdb_final), 2368 },
+{ HP_POP(itemdb->reload), HP_POP2(HP_itemdb_reload), 2370 },
+{ HP_POP(itemdb->name_constants), HP_POP2(HP_itemdb_name_constants), 2372 },
+{ HP_POP(itemdb->force_name_constants), HP_POP2(HP_itemdb_force_name_constants), 2374 },
+{ HP_POP(itemdb->read_groups), HP_POP2(HP_itemdb_read_groups), 2376 },
+{ HP_POP(itemdb->read_chains), HP_POP2(HP_itemdb_read_chains), 2378 },
+{ HP_POP(itemdb->read_packages), HP_POP2(HP_itemdb_read_packages), 2380 },
+{ HP_POP(itemdb->write_cached_packages), HP_POP2(HP_itemdb_write_cached_packages), 2382 },
+{ HP_POP(itemdb->read_cached_packages), HP_POP2(HP_itemdb_read_cached_packages), 2384 },
+{ HP_POP(itemdb->name2id), HP_POP2(HP_itemdb_name2id), 2386 },
+{ HP_POP(itemdb->search_name), HP_POP2(HP_itemdb_search_name), 2388 },
+{ HP_POP(itemdb->search_name_array), HP_POP2(HP_itemdb_search_name_array), 2390 },
+{ HP_POP(itemdb->load), HP_POP2(HP_itemdb_load), 2392 },
+{ HP_POP(itemdb->search), HP_POP2(HP_itemdb_search), 2394 },
+{ HP_POP(itemdb->parse_dbrow), HP_POP2(HP_itemdb_parse_dbrow), 2396 },
+{ HP_POP(itemdb->exists), HP_POP2(HP_itemdb_exists), 2398 },
+{ HP_POP(itemdb->in_group), HP_POP2(HP_itemdb_in_group), 2400 },
+{ HP_POP(itemdb->group_item), HP_POP2(HP_itemdb_group_item), 2402 },
+{ HP_POP(itemdb->chain_item), HP_POP2(HP_itemdb_chain_item), 2404 },
+{ HP_POP(itemdb->package_item), HP_POP2(HP_itemdb_package_item), 2406 },
+{ HP_POP(itemdb->searchname_sub), HP_POP2(HP_itemdb_searchname_sub), 2408 },
+{ HP_POP(itemdb->searchname_array_sub), HP_POP2(HP_itemdb_searchname_array_sub), 2410 },
+{ HP_POP(itemdb->searchrandomid), HP_POP2(HP_itemdb_searchrandomid), 2412 },
+{ HP_POP(itemdb->typename), HP_POP2(HP_itemdb_typename), 2414 },
+{ HP_POP(itemdb->jobid2mapid), HP_POP2(HP_itemdb_jobid2mapid), 2416 },
+{ HP_POP(itemdb->create_dummy_data), HP_POP2(HP_itemdb_create_dummy_data), 2418 },
+{ HP_POP(itemdb->create_item_data), HP_POP2(HP_itemdb_create_item_data), 2420 },
+{ HP_POP(itemdb->isequip), HP_POP2(HP_itemdb_isequip), 2422 },
+{ HP_POP(itemdb->isequip2), HP_POP2(HP_itemdb_isequip2), 2424 },
+{ HP_POP(itemdb->isstackable), HP_POP2(HP_itemdb_isstackable), 2426 },
+{ HP_POP(itemdb->isstackable2), HP_POP2(HP_itemdb_isstackable2), 2428 },
+{ HP_POP(itemdb->isdropable_sub), HP_POP2(HP_itemdb_isdropable_sub), 2430 },
+{ HP_POP(itemdb->cantrade_sub), HP_POP2(HP_itemdb_cantrade_sub), 2432 },
+{ HP_POP(itemdb->canpartnertrade_sub), HP_POP2(HP_itemdb_canpartnertrade_sub), 2434 },
+{ HP_POP(itemdb->cansell_sub), HP_POP2(HP_itemdb_cansell_sub), 2436 },
+{ HP_POP(itemdb->cancartstore_sub), HP_POP2(HP_itemdb_cancartstore_sub), 2438 },
+{ HP_POP(itemdb->canstore_sub), HP_POP2(HP_itemdb_canstore_sub), 2440 },
+{ HP_POP(itemdb->canguildstore_sub), HP_POP2(HP_itemdb_canguildstore_sub), 2442 },
+{ HP_POP(itemdb->canmail_sub), HP_POP2(HP_itemdb_canmail_sub), 2444 },
+{ HP_POP(itemdb->canauction_sub), HP_POP2(HP_itemdb_canauction_sub), 2446 },
+{ HP_POP(itemdb->isrestricted), HP_POP2(HP_itemdb_isrestricted), 2448 },
+{ HP_POP(itemdb->isidentified), HP_POP2(HP_itemdb_isidentified), 2450 },
+{ HP_POP(itemdb->isidentified2), HP_POP2(HP_itemdb_isidentified2), 2452 },
+{ HP_POP(itemdb->read_itemavail), HP_POP2(HP_itemdb_read_itemavail), 2454 },
+{ HP_POP(itemdb->read_itemtrade), HP_POP2(HP_itemdb_read_itemtrade), 2456 },
+{ HP_POP(itemdb->read_itemdelay), HP_POP2(HP_itemdb_read_itemdelay), 2458 },
+{ HP_POP(itemdb->read_stack), HP_POP2(HP_itemdb_read_stack), 2460 },
+{ HP_POP(itemdb->read_buyingstore), HP_POP2(HP_itemdb_read_buyingstore), 2462 },
+{ HP_POP(itemdb->read_nouse), HP_POP2(HP_itemdb_read_nouse), 2464 },
+{ HP_POP(itemdb->combo_split_atoi), HP_POP2(HP_itemdb_combo_split_atoi), 2466 },
+{ HP_POP(itemdb->read_combos), HP_POP2(HP_itemdb_read_combos), 2468 },
+{ HP_POP(itemdb->gendercheck), HP_POP2(HP_itemdb_gendercheck), 2470 },
+{ HP_POP(itemdb->re_split_atoi), HP_POP2(HP_itemdb_re_split_atoi), 2472 },
+{ HP_POP(itemdb->readdb), HP_POP2(HP_itemdb_readdb), 2474 },
+{ HP_POP(itemdb->read_sqldb), HP_POP2(HP_itemdb_read_sqldb), 2476 },
+{ HP_POP(itemdb->unique_id), HP_POP2(HP_itemdb_unique_id), 2478 },
+{ HP_POP(itemdb->uid_load), HP_POP2(HP_itemdb_uid_load), 2480 },
+{ HP_POP(itemdb->read), HP_POP2(HP_itemdb_read), 2482 },
+{ HP_POP(itemdb->destroy_item_data), HP_POP2(HP_itemdb_destroy_item_data), 2484 },
+{ HP_POP(itemdb->final_sub), HP_POP2(HP_itemdb_final_sub), 2486 },
+/* logs */
+{ HP_POP(logs->pick_pc), HP_POP2(HP_logs_pick_pc), 2488 },
+{ HP_POP(logs->pick_mob), HP_POP2(HP_logs_pick_mob), 2490 },
+{ HP_POP(logs->zeny), HP_POP2(HP_logs_zeny), 2492 },
+{ HP_POP(logs->npc), HP_POP2(HP_logs_npc), 2494 },
+{ HP_POP(logs->chat), HP_POP2(HP_logs_chat), 2496 },
+{ HP_POP(logs->atcommand), HP_POP2(HP_logs_atcommand), 2498 },
+{ HP_POP(logs->branch), HP_POP2(HP_logs_branch), 2500 },
+{ HP_POP(logs->mvpdrop), HP_POP2(HP_logs_mvpdrop), 2502 },
+{ HP_POP(logs->pick_sub), HP_POP2(HP_logs_pick_sub), 2504 },
+{ HP_POP(logs->zeny_sub), HP_POP2(HP_logs_zeny_sub), 2506 },
+{ HP_POP(logs->npc_sub), HP_POP2(HP_logs_npc_sub), 2508 },
+{ HP_POP(logs->chat_sub), HP_POP2(HP_logs_chat_sub), 2510 },
+{ HP_POP(logs->atcommand_sub), HP_POP2(HP_logs_atcommand_sub), 2512 },
+{ HP_POP(logs->branch_sub), HP_POP2(HP_logs_branch_sub), 2514 },
+{ HP_POP(logs->mvpdrop_sub), HP_POP2(HP_logs_mvpdrop_sub), 2516 },
+{ HP_POP(logs->config_read), HP_POP2(HP_logs_config_read), 2518 },
+{ HP_POP(logs->config_done), HP_POP2(HP_logs_config_done), 2520 },
+{ HP_POP(logs->sql_init), HP_POP2(HP_logs_sql_init), 2522 },
+{ HP_POP(logs->sql_final), HP_POP2(HP_logs_sql_final), 2524 },
+{ HP_POP(logs->picktype2char), HP_POP2(HP_logs_picktype2char), 2526 },
+{ HP_POP(logs->chattype2char), HP_POP2(HP_logs_chattype2char), 2528 },
+{ HP_POP(logs->should_log_item), HP_POP2(HP_logs_should_log_item), 2530 },
+/* mail */
+{ HP_POP(mail->clear), HP_POP2(HP_mail_clear), 2532 },
+{ HP_POP(mail->removeitem), HP_POP2(HP_mail_removeitem), 2534 },
+{ HP_POP(mail->removezeny), HP_POP2(HP_mail_removezeny), 2536 },
+{ HP_POP(mail->setitem), HP_POP2(HP_mail_setitem), 2538 },
+{ HP_POP(mail->setattachment), HP_POP2(HP_mail_setattachment), 2540 },
+{ HP_POP(mail->getattachment), HP_POP2(HP_mail_getattachment), 2542 },
+{ HP_POP(mail->openmail), HP_POP2(HP_mail_openmail), 2544 },
+{ HP_POP(mail->deliveryfail), HP_POP2(HP_mail_deliveryfail), 2546 },
+{ HP_POP(mail->invalid_operation), HP_POP2(HP_mail_invalid_operation), 2548 },
+/* map */
+{ HP_POP(map->zone_init), HP_POP2(HP_map_zone_init), 2550 },
+{ HP_POP(map->zone_remove), HP_POP2(HP_map_zone_remove), 2552 },
+{ HP_POP(map->zone_apply), HP_POP2(HP_map_zone_apply), 2554 },
+{ HP_POP(map->zone_change), HP_POP2(HP_map_zone_change), 2556 },
+{ HP_POP(map->zone_change2), HP_POP2(HP_map_zone_change2), 2558 },
+{ HP_POP(map->getcell), HP_POP2(HP_map_getcell), 2560 },
+{ HP_POP(map->setgatcell), HP_POP2(HP_map_setgatcell), 2562 },
+{ HP_POP(map->cellfromcache), HP_POP2(HP_map_cellfromcache), 2564 },
+{ HP_POP(map->setusers), HP_POP2(HP_map_setusers), 2566 },
+{ HP_POP(map->getusers), HP_POP2(HP_map_getusers), 2568 },
+{ HP_POP(map->usercount), HP_POP2(HP_map_usercount), 2570 },
+{ HP_POP(map->freeblock), HP_POP2(HP_map_freeblock), 2572 },
+{ HP_POP(map->freeblock_lock), HP_POP2(HP_map_freeblock_lock), 2574 },
+{ HP_POP(map->freeblock_unlock), HP_POP2(HP_map_freeblock_unlock), 2576 },
+{ HP_POP(map->addblock), HP_POP2(HP_map_addblock), 2578 },
+{ HP_POP(map->delblock), HP_POP2(HP_map_delblock), 2580 },
+{ HP_POP(map->moveblock), HP_POP2(HP_map_moveblock), 2582 },
+{ HP_POP(map->count_oncell), HP_POP2(HP_map_count_oncell), 2584 },
+{ HP_POP(map->find_skill_unit_oncell), HP_POP2(HP_map_find_skill_unit_oncell), 2586 },
+{ HP_POP(map->get_new_object_id), HP_POP2(HP_map_get_new_object_id), 2588 },
+{ HP_POP(map->search_freecell), HP_POP2(HP_map_search_freecell), 2590 },
+{ HP_POP(map->quit), HP_POP2(HP_map_quit), 2592 },
+{ HP_POP(map->addnpc), HP_POP2(HP_map_addnpc), 2594 },
+{ HP_POP(map->clearflooritem_timer), HP_POP2(HP_map_clearflooritem_timer), 2596 },
+{ HP_POP(map->removemobs_timer), HP_POP2(HP_map_removemobs_timer), 2598 },
+{ HP_POP(map->clearflooritem), HP_POP2(HP_map_clearflooritem), 2600 },
+{ HP_POP(map->addflooritem), HP_POP2(HP_map_addflooritem), 2602 },
+{ HP_POP(map->addnickdb), HP_POP2(HP_map_addnickdb), 2604 },
+{ HP_POP(map->delnickdb), HP_POP2(HP_map_delnickdb), 2606 },
+{ HP_POP(map->reqnickdb), HP_POP2(HP_map_reqnickdb), 2608 },
+{ HP_POP(map->charid2nick), HP_POP2(HP_map_charid2nick), 2610 },
+{ HP_POP(map->charid2sd), HP_POP2(HP_map_charid2sd), 2612 },
+{ HP_POP(map->vforeachpc), HP_POP2(HP_map_vforeachpc), 2614 },
+{ HP_POP(map->vforeachmob), HP_POP2(HP_map_vforeachmob), 2616 },
+{ HP_POP(map->vforeachnpc), HP_POP2(HP_map_vforeachnpc), 2618 },
+{ HP_POP(map->vforeachregen), HP_POP2(HP_map_vforeachregen), 2620 },
+{ HP_POP(map->vforeachiddb), HP_POP2(HP_map_vforeachiddb), 2622 },
+{ HP_POP(map->vforeachinrange), HP_POP2(HP_map_vforeachinrange), 2624 },
+{ HP_POP(map->vforeachinshootrange), HP_POP2(HP_map_vforeachinshootrange), 2626 },
+{ HP_POP(map->vforeachinarea), HP_POP2(HP_map_vforeachinarea), 2628 },
+{ HP_POP(map->vforcountinrange), HP_POP2(HP_map_vforcountinrange), 2630 },
+{ HP_POP(map->vforcountinarea), HP_POP2(HP_map_vforcountinarea), 2632 },
+{ HP_POP(map->vforeachinmovearea), HP_POP2(HP_map_vforeachinmovearea), 2634 },
+{ HP_POP(map->vforeachincell), HP_POP2(HP_map_vforeachincell), 2636 },
+{ HP_POP(map->vforeachinpath), HP_POP2(HP_map_vforeachinpath), 2638 },
+{ HP_POP(map->vforeachinmap), HP_POP2(HP_map_vforeachinmap), 2640 },
+{ HP_POP(map->vforeachininstance), HP_POP2(HP_map_vforeachininstance), 2642 },
+{ HP_POP(map->id2sd), HP_POP2(HP_map_id2sd), 2644 },
+{ HP_POP(map->id2md), HP_POP2(HP_map_id2md), 2646 },
+{ HP_POP(map->id2nd), HP_POP2(HP_map_id2nd), 2648 },
+{ HP_POP(map->id2hd), HP_POP2(HP_map_id2hd), 2650 },
+{ HP_POP(map->id2mc), HP_POP2(HP_map_id2mc), 2652 },
+{ HP_POP(map->id2cd), HP_POP2(HP_map_id2cd), 2654 },
+{ HP_POP(map->id2bl), HP_POP2(HP_map_id2bl), 2656 },
+{ HP_POP(map->blid_exists), HP_POP2(HP_map_blid_exists), 2658 },
+{ HP_POP(map->mapindex2mapid), HP_POP2(HP_map_mapindex2mapid), 2660 },
+{ HP_POP(map->mapname2mapid), HP_POP2(HP_map_mapname2mapid), 2662 },
+{ HP_POP(map->mapname2ipport), HP_POP2(HP_map_mapname2ipport), 2664 },
+{ HP_POP(map->setipport), HP_POP2(HP_map_setipport), 2666 },
+{ HP_POP(map->eraseipport), HP_POP2(HP_map_eraseipport), 2668 },
+{ HP_POP(map->eraseallipport), HP_POP2(HP_map_eraseallipport), 2670 },
+{ HP_POP(map->addiddb), HP_POP2(HP_map_addiddb), 2672 },
+{ HP_POP(map->deliddb), HP_POP2(HP_map_deliddb), 2674 },
+{ HP_POP(map->nick2sd), HP_POP2(HP_map_nick2sd), 2676 },
+{ HP_POP(map->getmob_boss), HP_POP2(HP_map_getmob_boss), 2678 },
+{ HP_POP(map->id2boss), HP_POP2(HP_map_id2boss), 2680 },
+{ HP_POP(map->reloadnpc), HP_POP2(HP_map_reloadnpc), 2682 },
+{ HP_POP(map->check_dir), HP_POP2(HP_map_check_dir), 2684 },
+{ HP_POP(map->calc_dir), HP_POP2(HP_map_calc_dir), 2686 },
+{ HP_POP(map->random_dir), HP_POP2(HP_map_random_dir), 2688 },
+{ HP_POP(map->cleanup_sub), HP_POP2(HP_map_cleanup_sub), 2690 },
+{ HP_POP(map->delmap), HP_POP2(HP_map_delmap), 2692 },
+{ HP_POP(map->flags_init), HP_POP2(HP_map_flags_init), 2694 },
+{ HP_POP(map->iwall_set), HP_POP2(HP_map_iwall_set), 2696 },
+{ HP_POP(map->iwall_get), HP_POP2(HP_map_iwall_get), 2698 },
+{ HP_POP(map->iwall_remove), HP_POP2(HP_map_iwall_remove), 2700 },
+{ HP_POP(map->addmobtolist), HP_POP2(HP_map_addmobtolist), 2702 },
+{ HP_POP(map->spawnmobs), HP_POP2(HP_map_spawnmobs), 2704 },
+{ HP_POP(map->removemobs), HP_POP2(HP_map_removemobs), 2706 },
+{ HP_POP(map->addmap2db), HP_POP2(HP_map_addmap2db), 2708 },
+{ HP_POP(map->removemapdb), HP_POP2(HP_map_removemapdb), 2710 },
+{ HP_POP(map->clean), HP_POP2(HP_map_clean), 2712 },
+{ HP_POP(map->do_shutdown), HP_POP2(HP_map_do_shutdown), 2714 },
+{ HP_POP(map->freeblock_timer), HP_POP2(HP_map_freeblock_timer), 2716 },
+{ HP_POP(map->searchrandfreecell), HP_POP2(HP_map_searchrandfreecell), 2718 },
+{ HP_POP(map->count_sub), HP_POP2(HP_map_count_sub), 2720 },
+{ HP_POP(map->create_charid2nick), HP_POP2(HP_map_create_charid2nick), 2722 },
+{ HP_POP(map->removemobs_sub), HP_POP2(HP_map_removemobs_sub), 2724 },
+{ HP_POP(map->gat2cell), HP_POP2(HP_map_gat2cell), 2726 },
+{ HP_POP(map->cell2gat), HP_POP2(HP_map_cell2gat), 2728 },
+{ HP_POP(map->getcellp), HP_POP2(HP_map_getcellp), 2730 },
+{ HP_POP(map->setcell), HP_POP2(HP_map_setcell), 2732 },
+{ HP_POP(map->sub_getcellp), HP_POP2(HP_map_sub_getcellp), 2734 },
+{ HP_POP(map->sub_setcell), HP_POP2(HP_map_sub_setcell), 2736 },
+{ HP_POP(map->iwall_nextxy), HP_POP2(HP_map_iwall_nextxy), 2738 },
+{ HP_POP(map->create_map_data_other_server), HP_POP2(HP_map_create_map_data_other_server), 2740 },
+{ HP_POP(map->eraseallipport_sub), HP_POP2(HP_map_eraseallipport_sub), 2742 },
+{ HP_POP(map->init_mapcache), HP_POP2(HP_map_init_mapcache), 2744 },
+{ HP_POP(map->readfromcache), HP_POP2(HP_map_readfromcache), 2746 },
+{ HP_POP(map->addmap), HP_POP2(HP_map_addmap), 2748 },
+{ HP_POP(map->delmapid), HP_POP2(HP_map_delmapid), 2750 },
+{ HP_POP(map->zone_db_clear), HP_POP2(HP_map_zone_db_clear), 2752 },
+{ HP_POP(map->list_final), HP_POP2(HP_map_list_final), 2754 },
+{ HP_POP(map->waterheight), HP_POP2(HP_map_waterheight), 2756 },
+{ HP_POP(map->readgat), HP_POP2(HP_map_readgat), 2758 },
+{ HP_POP(map->readallmaps), HP_POP2(HP_map_readallmaps), 2760 },
+{ HP_POP(map->config_read), HP_POP2(HP_map_config_read), 2762 },
+{ HP_POP(map->config_read_sub), HP_POP2(HP_map_config_read_sub), 2764 },
+{ HP_POP(map->reloadnpc_sub), HP_POP2(HP_map_reloadnpc_sub), 2766 },
+{ HP_POP(map->inter_config_read), HP_POP2(HP_map_inter_config_read), 2768 },
+{ HP_POP(map->sql_init), HP_POP2(HP_map_sql_init), 2770 },
+{ HP_POP(map->sql_close), HP_POP2(HP_map_sql_close), 2772 },
+{ HP_POP(map->zone_mf_cache), HP_POP2(HP_map_zone_mf_cache), 2774 },
+{ HP_POP(map->zone_str2itemid), HP_POP2(HP_map_zone_str2itemid), 2776 },
+{ HP_POP(map->zone_str2skillid), HP_POP2(HP_map_zone_str2skillid), 2778 },
+{ HP_POP(map->zone_bl_type), HP_POP2(HP_map_zone_bl_type), 2780 },
+{ HP_POP(map->read_zone_db), HP_POP2(HP_map_read_zone_db), 2782 },
+{ HP_POP(map->db_final), HP_POP2(HP_map_db_final), 2784 },
+{ HP_POP(map->nick_db_final), HP_POP2(HP_map_nick_db_final), 2786 },
+{ HP_POP(map->cleanup_db_sub), HP_POP2(HP_map_cleanup_db_sub), 2788 },
+{ HP_POP(map->abort_sub), HP_POP2(HP_map_abort_sub), 2790 },
+{ HP_POP(map->helpscreen), HP_POP2(HP_map_helpscreen), 2792 },
+{ HP_POP(map->versionscreen), HP_POP2(HP_map_versionscreen), 2794 },
+{ HP_POP(map->arg_next_value), HP_POP2(HP_map_arg_next_value), 2796 },
+/* mapit */
+{ HP_POP(mapit->alloc), HP_POP2(HP_mapit_alloc), 2798 },
+{ HP_POP(mapit->free), HP_POP2(HP_mapit_free), 2800 },
+{ HP_POP(mapit->first), HP_POP2(HP_mapit_first), 2802 },
+{ HP_POP(mapit->last), HP_POP2(HP_mapit_last), 2804 },
+{ HP_POP(mapit->next), HP_POP2(HP_mapit_next), 2806 },
+{ HP_POP(mapit->prev), HP_POP2(HP_mapit_prev), 2808 },
+{ HP_POP(mapit->exists), HP_POP2(HP_mapit_exists), 2810 },
+/* mapreg */
+{ HP_POP(mapreg->init), HP_POP2(HP_mapreg_init), 2812 },
+{ HP_POP(mapreg->final), HP_POP2(HP_mapreg_final), 2814 },
+{ HP_POP(mapreg->readreg), HP_POP2(HP_mapreg_readreg), 2816 },
+{ HP_POP(mapreg->readregstr), HP_POP2(HP_mapreg_readregstr), 2818 },
+{ HP_POP(mapreg->setreg), HP_POP2(HP_mapreg_setreg), 2820 },
+{ HP_POP(mapreg->setregstr), HP_POP2(HP_mapreg_setregstr), 2822 },
+{ HP_POP(mapreg->load), HP_POP2(HP_mapreg_load), 2824 },
+{ HP_POP(mapreg->save), HP_POP2(HP_mapreg_save), 2826 },
+{ HP_POP(mapreg->save_timer), HP_POP2(HP_mapreg_save_timer), 2828 },
+{ HP_POP(mapreg->reload), HP_POP2(HP_mapreg_reload), 2830 },
+{ HP_POP(mapreg->config_read), HP_POP2(HP_mapreg_config_read), 2832 },
+/* mercenary */
+{ HP_POP(mercenary->init), HP_POP2(HP_mercenary_init), 2834 },
+{ HP_POP(mercenary->class), HP_POP2(HP_mercenary_class), 2836 },
+{ HP_POP(mercenary->get_viewdata), HP_POP2(HP_mercenary_get_viewdata), 2838 },
+{ HP_POP(mercenary->create), HP_POP2(HP_mercenary_create), 2840 },
+{ HP_POP(mercenary->data_received), HP_POP2(HP_mercenary_data_received), 2842 },
+{ HP_POP(mercenary->save), HP_POP2(HP_mercenary_save), 2844 },
+{ HP_POP(mercenary->heal), HP_POP2(HP_mercenary_heal), 2846 },
+{ HP_POP(mercenary->dead), HP_POP2(HP_mercenary_dead), 2848 },
+{ HP_POP(mercenary->delete), HP_POP2(HP_mercenary_delete), 2850 },
+{ HP_POP(mercenary->contract_stop), HP_POP2(HP_mercenary_contract_stop), 2852 },
+{ HP_POP(mercenary->get_lifetime), HP_POP2(HP_mercenary_get_lifetime), 2854 },
+{ HP_POP(mercenary->get_guild), HP_POP2(HP_mercenary_get_guild), 2856 },
+{ HP_POP(mercenary->get_faith), HP_POP2(HP_mercenary_get_faith), 2858 },
+{ HP_POP(mercenary->set_faith), HP_POP2(HP_mercenary_set_faith), 2860 },
+{ HP_POP(mercenary->get_calls), HP_POP2(HP_mercenary_get_calls), 2862 },
+{ HP_POP(mercenary->set_calls), HP_POP2(HP_mercenary_set_calls), 2864 },
+{ HP_POP(mercenary->kills), HP_POP2(HP_mercenary_kills), 2866 },
+{ HP_POP(mercenary->checkskill), HP_POP2(HP_mercenary_checkskill), 2868 },
+{ HP_POP(mercenary->read_db), HP_POP2(HP_mercenary_read_db), 2870 },
+{ HP_POP(mercenary->read_skilldb), HP_POP2(HP_mercenary_read_skilldb), 2872 },
+{ HP_POP(mercenary->killbonus), HP_POP2(HP_mercenary_killbonus), 2874 },
+{ HP_POP(mercenary->search_index), HP_POP2(HP_mercenary_search_index), 2876 },
+{ HP_POP(mercenary->contract_end_timer), HP_POP2(HP_mercenary_contract_end_timer), 2878 },
+{ HP_POP(mercenary->read_db_sub), HP_POP2(HP_mercenary_read_db_sub), 2880 },
+{ HP_POP(mercenary->read_skill_db_sub), HP_POP2(HP_mercenary_read_skill_db_sub), 2882 },
+/* mob */
+{ HP_POP(mob->init), HP_POP2(HP_mob_init), 2884 },
+{ HP_POP(mob->final), HP_POP2(HP_mob_final), 2886 },
+{ HP_POP(mob->reload), HP_POP2(HP_mob_reload), 2888 },
+{ HP_POP(mob->db), HP_POP2(HP_mob_db), 2890 },
+{ HP_POP(mob->chat), HP_POP2(HP_mob_chat), 2892 },
+{ HP_POP(mob->makedummymobdb), HP_POP2(HP_mob_makedummymobdb), 2894 },
+{ HP_POP(mob->spawn_guardian_sub), HP_POP2(HP_mob_spawn_guardian_sub), 2896 },
+{ HP_POP(mob->skill_id2skill_idx), HP_POP2(HP_mob_skill_id2skill_idx), 2898 },
+{ HP_POP(mob->db_searchname), HP_POP2(HP_mob_db_searchname), 2900 },
+{ HP_POP(mob->db_searchname_array_sub), HP_POP2(HP_mob_db_searchname_array_sub), 2902 },
+{ HP_POP(mob->mvptomb_create), HP_POP2(HP_mob_mvptomb_create), 2904 },
+{ HP_POP(mob->mvptomb_destroy), HP_POP2(HP_mob_mvptomb_destroy), 2906 },
+{ HP_POP(mob->db_searchname_array), HP_POP2(HP_mob_db_searchname_array), 2908 },
+{ HP_POP(mob->db_checkid), HP_POP2(HP_mob_db_checkid), 2910 },
+{ HP_POP(mob->get_viewdata), HP_POP2(HP_mob_get_viewdata), 2912 },
+{ HP_POP(mob->parse_dataset), HP_POP2(HP_mob_parse_dataset), 2914 },
+{ HP_POP(mob->spawn_dataset), HP_POP2(HP_mob_spawn_dataset), 2916 },
+{ HP_POP(mob->get_random_id), HP_POP2(HP_mob_get_random_id), 2918 },
+{ HP_POP(mob->ksprotected), HP_POP2(HP_mob_ksprotected), 2920 },
+{ HP_POP(mob->once_spawn_sub), HP_POP2(HP_mob_once_spawn_sub), 2922 },
+{ HP_POP(mob->once_spawn), HP_POP2(HP_mob_once_spawn), 2924 },
+{ HP_POP(mob->once_spawn_area), HP_POP2(HP_mob_once_spawn_area), 2926 },
+{ HP_POP(mob->spawn_guardian), HP_POP2(HP_mob_spawn_guardian), 2928 },
+{ HP_POP(mob->spawn_bg), HP_POP2(HP_mob_spawn_bg), 2930 },
+{ HP_POP(mob->can_reach), HP_POP2(HP_mob_can_reach), 2932 },
+{ HP_POP(mob->linksearch), HP_POP2(HP_mob_linksearch), 2934 },
+{ HP_POP(mob->delayspawn), HP_POP2(HP_mob_delayspawn), 2936 },
+{ HP_POP(mob->setdelayspawn), HP_POP2(HP_mob_setdelayspawn), 2938 },
+{ HP_POP(mob->count_sub), HP_POP2(HP_mob_count_sub), 2940 },
+{ HP_POP(mob->spawn), HP_POP2(HP_mob_spawn), 2942 },
+{ HP_POP(mob->can_changetarget), HP_POP2(HP_mob_can_changetarget), 2944 },
+{ HP_POP(mob->target), HP_POP2(HP_mob_target), 2946 },
+{ HP_POP(mob->ai_sub_hard_activesearch), HP_POP2(HP_mob_ai_sub_hard_activesearch), 2948 },
+{ HP_POP(mob->ai_sub_hard_changechase), HP_POP2(HP_mob_ai_sub_hard_changechase), 2950 },
+{ HP_POP(mob->ai_sub_hard_bg_ally), HP_POP2(HP_mob_ai_sub_hard_bg_ally), 2952 },
+{ HP_POP(mob->ai_sub_hard_lootsearch), HP_POP2(HP_mob_ai_sub_hard_lootsearch), 2954 },
+{ HP_POP(mob->warpchase_sub), HP_POP2(HP_mob_warpchase_sub), 2956 },
+{ HP_POP(mob->ai_sub_hard_slavemob), HP_POP2(HP_mob_ai_sub_hard_slavemob), 2958 },
+{ HP_POP(mob->unlocktarget), HP_POP2(HP_mob_unlocktarget), 2960 },
+{ HP_POP(mob->randomwalk), HP_POP2(HP_mob_randomwalk), 2962 },
+{ HP_POP(mob->warpchase), HP_POP2(HP_mob_warpchase), 2964 },
+{ HP_POP(mob->ai_sub_hard), HP_POP2(HP_mob_ai_sub_hard), 2966 },
+{ HP_POP(mob->ai_sub_hard_timer), HP_POP2(HP_mob_ai_sub_hard_timer), 2968 },
+{ HP_POP(mob->ai_sub_foreachclient), HP_POP2(HP_mob_ai_sub_foreachclient), 2970 },
+{ HP_POP(mob->ai_sub_lazy), HP_POP2(HP_mob_ai_sub_lazy), 2972 },
+{ HP_POP(mob->ai_lazy), HP_POP2(HP_mob_ai_lazy), 2974 },
+{ HP_POP(mob->ai_hard), HP_POP2(HP_mob_ai_hard), 2976 },
+{ HP_POP(mob->setdropitem), HP_POP2(HP_mob_setdropitem), 2978 },
+{ HP_POP(mob->setlootitem), HP_POP2(HP_mob_setlootitem), 2980 },
+{ HP_POP(mob->delay_item_drop), HP_POP2(HP_mob_delay_item_drop), 2982 },
+{ HP_POP(mob->item_drop), HP_POP2(HP_mob_item_drop), 2984 },
+{ HP_POP(mob->timer_delete), HP_POP2(HP_mob_timer_delete), 2986 },
+{ HP_POP(mob->deleteslave_sub), HP_POP2(HP_mob_deleteslave_sub), 2988 },
+{ HP_POP(mob->deleteslave), HP_POP2(HP_mob_deleteslave), 2990 },
+{ HP_POP(mob->respawn), HP_POP2(HP_mob_respawn), 2992 },
+{ HP_POP(mob->log_damage), HP_POP2(HP_mob_log_damage), 2994 },
+{ HP_POP(mob->damage), HP_POP2(HP_mob_damage), 2996 },
+{ HP_POP(mob->dead), HP_POP2(HP_mob_dead), 2998 },
+{ HP_POP(mob->revive), HP_POP2(HP_mob_revive), 3000 },
+{ HP_POP(mob->guardian_guildchange), HP_POP2(HP_mob_guardian_guildchange), 3002 },
+{ HP_POP(mob->random_class), HP_POP2(HP_mob_random_class), 3004 },
+{ HP_POP(mob->class_change), HP_POP2(HP_mob_class_change), 3006 },
+{ HP_POP(mob->heal), HP_POP2(HP_mob_heal), 3008 },
+{ HP_POP(mob->warpslave_sub), HP_POP2(HP_mob_warpslave_sub), 3010 },
+{ HP_POP(mob->warpslave), HP_POP2(HP_mob_warpslave), 3012 },
+{ HP_POP(mob->countslave_sub), HP_POP2(HP_mob_countslave_sub), 3014 },
+{ HP_POP(mob->countslave), HP_POP2(HP_mob_countslave), 3016 },
+{ HP_POP(mob->summonslave), HP_POP2(HP_mob_summonslave), 3018 },
+{ HP_POP(mob->getfriendhprate_sub), HP_POP2(HP_mob_getfriendhprate_sub), 3020 },
+{ HP_POP(mob->getfriendhprate), HP_POP2(HP_mob_getfriendhprate), 3022 },
+{ HP_POP(mob->getmasterhpltmaxrate), HP_POP2(HP_mob_getmasterhpltmaxrate), 3024 },
+{ HP_POP(mob->getfriendstatus_sub), HP_POP2(HP_mob_getfriendstatus_sub), 3026 },
+{ HP_POP(mob->getfriendstatus), HP_POP2(HP_mob_getfriendstatus), 3028 },
+{ HP_POP(mob->skill_use), HP_POP2(HP_mob_skill_use), 3030 },
+{ HP_POP(mob->skill_event), HP_POP2(HP_mob_skill_event), 3032 },
+{ HP_POP(mob->is_clone), HP_POP2(HP_mob_is_clone), 3034 },
+{ HP_POP(mob->clone_spawn), HP_POP2(HP_mob_clone_spawn), 3036 },
+{ HP_POP(mob->clone_delete), HP_POP2(HP_mob_clone_delete), 3038 },
+{ HP_POP(mob->drop_adjust), HP_POP2(HP_mob_drop_adjust), 3040 },
+{ HP_POP(mob->item_dropratio_adjust), HP_POP2(HP_mob_item_dropratio_adjust), 3042 },
+{ HP_POP(mob->parse_dbrow), HP_POP2(HP_mob_parse_dbrow), 3044 },
+{ HP_POP(mob->readdb_sub), HP_POP2(HP_mob_readdb_sub), 3046 },
+{ HP_POP(mob->readdb), HP_POP2(HP_mob_readdb), 3048 },
+{ HP_POP(mob->read_sqldb), HP_POP2(HP_mob_read_sqldb), 3050 },
+{ HP_POP(mob->readdb_mobavail), HP_POP2(HP_mob_readdb_mobavail), 3052 },
+{ HP_POP(mob->read_randommonster), HP_POP2(HP_mob_read_randommonster), 3054 },
+{ HP_POP(mob->parse_row_chatdb), HP_POP2(HP_mob_parse_row_chatdb), 3056 },
+{ HP_POP(mob->readchatdb), HP_POP2(HP_mob_readchatdb), 3058 },
+{ HP_POP(mob->parse_row_mobskilldb), HP_POP2(HP_mob_parse_row_mobskilldb), 3060 },
+{ HP_POP(mob->readskilldb), HP_POP2(HP_mob_readskilldb), 3062 },
+{ HP_POP(mob->read_sqlskilldb), HP_POP2(HP_mob_read_sqlskilldb), 3064 },
+{ HP_POP(mob->readdb_race2), HP_POP2(HP_mob_readdb_race2), 3066 },
+{ HP_POP(mob->readdb_itemratio), HP_POP2(HP_mob_readdb_itemratio), 3068 },
+{ HP_POP(mob->load), HP_POP2(HP_mob_load), 3070 },
+{ HP_POP(mob->clear_spawninfo), HP_POP2(HP_mob_clear_spawninfo), 3072 },
+/* npc */
+{ HP_POP(npc->init), HP_POP2(HP_npc_init), 3074 },
+{ HP_POP(npc->final), HP_POP2(HP_npc_final), 3076 },
+{ HP_POP(npc->get_new_npc_id), HP_POP2(HP_npc_get_new_npc_id), 3078 },
+{ HP_POP(npc->get_viewdata), HP_POP2(HP_npc_get_viewdata), 3080 },
+{ HP_POP(npc->isnear_sub), HP_POP2(HP_npc_isnear_sub), 3082 },
+{ HP_POP(npc->isnear), HP_POP2(HP_npc_isnear), 3084 },
+{ HP_POP(npc->ontouch_event), HP_POP2(HP_npc_ontouch_event), 3086 },
+{ HP_POP(npc->ontouch2_event), HP_POP2(HP_npc_ontouch2_event), 3088 },
+{ HP_POP(npc->enable_sub), HP_POP2(HP_npc_enable_sub), 3090 },
+{ HP_POP(npc->enable), HP_POP2(HP_npc_enable), 3092 },
+{ HP_POP(npc->name2id), HP_POP2(HP_npc_name2id), 3094 },
+{ HP_POP(npc->event_dequeue), HP_POP2(HP_npc_event_dequeue), 3096 },
+{ HP_POP(npc->event_export_create), HP_POP2(HP_npc_event_export_create), 3098 },
+{ HP_POP(npc->event_export), HP_POP2(HP_npc_event_export), 3100 },
+{ HP_POP(npc->event_sub), HP_POP2(HP_npc_event_sub), 3102 },
+{ HP_POP(npc->event_doall_sub), HP_POP2(HP_npc_event_doall_sub), 3104 },
+{ HP_POP(npc->event_do), HP_POP2(HP_npc_event_do), 3106 },
+{ HP_POP(npc->event_doall_id), HP_POP2(HP_npc_event_doall_id), 3108 },
+{ HP_POP(npc->event_doall), HP_POP2(HP_npc_event_doall), 3110 },
+{ HP_POP(npc->event_do_clock), HP_POP2(HP_npc_event_do_clock), 3112 },
+{ HP_POP(npc->event_do_oninit), HP_POP2(HP_npc_event_do_oninit), 3114 },
+{ HP_POP(npc->timerevent_export), HP_POP2(HP_npc_timerevent_export), 3116 },
+{ HP_POP(npc->timerevent), HP_POP2(HP_npc_timerevent), 3118 },
+{ HP_POP(npc->timerevent_start), HP_POP2(HP_npc_timerevent_start), 3120 },
+{ HP_POP(npc->timerevent_stop), HP_POP2(HP_npc_timerevent_stop), 3122 },
+{ HP_POP(npc->timerevent_quit), HP_POP2(HP_npc_timerevent_quit), 3124 },
+{ HP_POP(npc->gettimerevent_tick), HP_POP2(HP_npc_gettimerevent_tick), 3126 },
+{ HP_POP(npc->settimerevent_tick), HP_POP2(HP_npc_settimerevent_tick), 3128 },
+{ HP_POP(npc->event), HP_POP2(HP_npc_event), 3130 },
+{ HP_POP(npc->touch_areanpc_sub), HP_POP2(HP_npc_touch_areanpc_sub), 3132 },
+{ HP_POP(npc->touchnext_areanpc), HP_POP2(HP_npc_touchnext_areanpc), 3134 },
+{ HP_POP(npc->touch_areanpc), HP_POP2(HP_npc_touch_areanpc), 3136 },
+{ HP_POP(npc->touch_areanpc2), HP_POP2(HP_npc_touch_areanpc2), 3138 },
+{ HP_POP(npc->check_areanpc), HP_POP2(HP_npc_check_areanpc), 3140 },
+{ HP_POP(npc->checknear), HP_POP2(HP_npc_checknear), 3142 },
+{ HP_POP(npc->globalmessage), HP_POP2(HP_npc_globalmessage), 3144 },
+{ HP_POP(npc->run_tomb), HP_POP2(HP_npc_run_tomb), 3146 },
+{ HP_POP(npc->click), HP_POP2(HP_npc_click), 3148 },
+{ HP_POP(npc->scriptcont), HP_POP2(HP_npc_scriptcont), 3150 },
+{ HP_POP(npc->buysellsel), HP_POP2(HP_npc_buysellsel), 3152 },
+{ HP_POP(npc->cashshop_buylist), HP_POP2(HP_npc_cashshop_buylist), 3154 },
+{ HP_POP(npc->buylist_sub), HP_POP2(HP_npc_buylist_sub), 3156 },
+{ HP_POP(npc->cashshop_buy), HP_POP2(HP_npc_cashshop_buy), 3158 },
+{ HP_POP(npc->buylist), HP_POP2(HP_npc_buylist), 3160 },
+{ HP_POP(npc->selllist_sub), HP_POP2(HP_npc_selllist_sub), 3162 },
+{ HP_POP(npc->selllist), HP_POP2(HP_npc_selllist), 3164 },
+{ HP_POP(npc->remove_map), HP_POP2(HP_npc_remove_map), 3166 },
+{ HP_POP(npc->unload_ev), HP_POP2(HP_npc_unload_ev), 3168 },
+{ HP_POP(npc->unload_ev_label), HP_POP2(HP_npc_unload_ev_label), 3170 },
+{ HP_POP(npc->unload_dup_sub), HP_POP2(HP_npc_unload_dup_sub), 3172 },
+{ HP_POP(npc->unload_duplicates), HP_POP2(HP_npc_unload_duplicates), 3174 },
+{ HP_POP(npc->unload), HP_POP2(HP_npc_unload), 3176 },
+{ HP_POP(npc->clearsrcfile), HP_POP2(HP_npc_clearsrcfile), 3178 },
+{ HP_POP(npc->addsrcfile), HP_POP2(HP_npc_addsrcfile), 3180 },
+{ HP_POP(npc->delsrcfile), HP_POP2(HP_npc_delsrcfile), 3182 },
+{ HP_POP(npc->parsename), HP_POP2(HP_npc_parsename), 3184 },
+{ HP_POP(npc->add_warp), HP_POP2(HP_npc_add_warp), 3186 },
+{ HP_POP(npc->parse_warp), HP_POP2(HP_npc_parse_warp), 3188 },
+{ HP_POP(npc->parse_shop), HP_POP2(HP_npc_parse_shop), 3190 },
+{ HP_POP(npc->convertlabel_db), HP_POP2(HP_npc_convertlabel_db), 3192 },
+{ HP_POP(npc->skip_script), HP_POP2(HP_npc_skip_script), 3194 },
+{ HP_POP(npc->parse_script), HP_POP2(HP_npc_parse_script), 3196 },
+{ HP_POP(npc->parse_duplicate), HP_POP2(HP_npc_parse_duplicate), 3198 },
+{ HP_POP(npc->duplicate4instance), HP_POP2(HP_npc_duplicate4instance), 3200 },
+{ HP_POP(npc->setcells), HP_POP2(HP_npc_setcells), 3202 },
+{ HP_POP(npc->unsetcells_sub), HP_POP2(HP_npc_unsetcells_sub), 3204 },
+{ HP_POP(npc->unsetcells), HP_POP2(HP_npc_unsetcells), 3206 },
+{ HP_POP(npc->movenpc), HP_POP2(HP_npc_movenpc), 3208 },
+{ HP_POP(npc->setdisplayname), HP_POP2(HP_npc_setdisplayname), 3210 },
+{ HP_POP(npc->setclass), HP_POP2(HP_npc_setclass), 3212 },
+{ HP_POP(npc->do_atcmd_event), HP_POP2(HP_npc_do_atcmd_event), 3214 },
+{ HP_POP(npc->parse_function), HP_POP2(HP_npc_parse_function), 3216 },
+{ HP_POP(npc->parse_mob2), HP_POP2(HP_npc_parse_mob2), 3218 },
+{ HP_POP(npc->parse_mob), HP_POP2(HP_npc_parse_mob), 3220 },
+{ HP_POP(npc->parse_mapflag), HP_POP2(HP_npc_parse_mapflag), 3222 },
+{ HP_POP(npc->parsesrcfile), HP_POP2(HP_npc_parsesrcfile), 3224 },
+{ HP_POP(npc->script_event), HP_POP2(HP_npc_script_event), 3226 },
+{ HP_POP(npc->read_event_script), HP_POP2(HP_npc_read_event_script), 3228 },
+{ HP_POP(npc->path_db_clear_sub), HP_POP2(HP_npc_path_db_clear_sub), 3230 },
+{ HP_POP(npc->ev_label_db_clear_sub), HP_POP2(HP_npc_ev_label_db_clear_sub), 3232 },
+{ HP_POP(npc->reload), HP_POP2(HP_npc_reload), 3234 },
+{ HP_POP(npc->unloadfile), HP_POP2(HP_npc_unloadfile), 3236 },
+{ HP_POP(npc->do_clear_npc), HP_POP2(HP_npc_do_clear_npc), 3238 },
+{ HP_POP(npc->debug_warps_sub), HP_POP2(HP_npc_debug_warps_sub), 3240 },
+{ HP_POP(npc->debug_warps), HP_POP2(HP_npc_debug_warps), 3242 },
+/* party */
+{ HP_POP(party->init), HP_POP2(HP_party_init), 3244 },
+{ HP_POP(party->final), HP_POP2(HP_party_final), 3246 },
+{ HP_POP(party->search), HP_POP2(HP_party_search), 3248 },
+{ HP_POP(party->searchname), HP_POP2(HP_party_searchname), 3250 },
+{ HP_POP(party->getmemberid), HP_POP2(HP_party_getmemberid), 3252 },
+{ HP_POP(party->getavailablesd), HP_POP2(HP_party_getavailablesd), 3254 },
+{ HP_POP(party->create), HP_POP2(HP_party_create), 3256 },
+{ HP_POP(party->created), HP_POP2(HP_party_created), 3258 },
+{ HP_POP(party->request_info), HP_POP2(HP_party_request_info), 3260 },
+{ HP_POP(party->invite), HP_POP2(HP_party_invite), 3262 },
+{ HP_POP(party->member_joined), HP_POP2(HP_party_member_joined), 3264 },
+{ HP_POP(party->member_added), HP_POP2(HP_party_member_added), 3266 },
+{ HP_POP(party->leave), HP_POP2(HP_party_leave), 3268 },
+{ HP_POP(party->removemember), HP_POP2(HP_party_removemember), 3270 },
+{ HP_POP(party->member_withdraw), HP_POP2(HP_party_member_withdraw), 3272 },
+{ HP_POP(party->reply_invite), HP_POP2(HP_party_reply_invite), 3274 },
+{ HP_POP(party->recv_noinfo), HP_POP2(HP_party_recv_noinfo), 3276 },
+{ HP_POP(party->recv_info), HP_POP2(HP_party_recv_info), 3278 },
+{ HP_POP(party->recv_movemap), HP_POP2(HP_party_recv_movemap), 3280 },
+{ HP_POP(party->broken), HP_POP2(HP_party_broken), 3282 },
+{ HP_POP(party->optionchanged), HP_POP2(HP_party_optionchanged), 3284 },
+{ HP_POP(party->changeoption), HP_POP2(HP_party_changeoption), 3286 },
+{ HP_POP(party->changeleader), HP_POP2(HP_party_changeleader), 3288 },
+{ HP_POP(party->send_movemap), HP_POP2(HP_party_send_movemap), 3290 },
+{ HP_POP(party->send_levelup), HP_POP2(HP_party_send_levelup), 3292 },
+{ HP_POP(party->send_logout), HP_POP2(HP_party_send_logout), 3294 },
+{ HP_POP(party->send_message), HP_POP2(HP_party_send_message), 3296 },
+{ HP_POP(party->recv_message), HP_POP2(HP_party_recv_message), 3298 },
+{ HP_POP(party->skill_check), HP_POP2(HP_party_skill_check), 3300 },
+{ HP_POP(party->send_xy_clear), HP_POP2(HP_party_send_xy_clear), 3302 },
+{ HP_POP(party->exp_share), HP_POP2(HP_party_exp_share), 3304 },
+{ HP_POP(party->share_loot), HP_POP2(HP_party_share_loot), 3306 },
+{ HP_POP(party->send_dot_remove), HP_POP2(HP_party_send_dot_remove), 3308 },
+{ HP_POP(party->sub_count), HP_POP2(HP_party_sub_count), 3310 },
+{ HP_POP(party->booking_register), HP_POP2(HP_party_booking_register), 3312 },
+{ HP_POP(party->booking_update), HP_POP2(HP_party_booking_update), 3314 },
+{ HP_POP(party->booking_search), HP_POP2(HP_party_booking_search), 3316 },
+{ HP_POP(party->booking_delete), HP_POP2(HP_party_booking_delete), 3318 },
+{ HP_POP(party->vforeachsamemap), HP_POP2(HP_party_vforeachsamemap), 3320 },
+{ HP_POP(party->send_xy_timer), HP_POP2(HP_party_send_xy_timer), 3322 },
+{ HP_POP(party->fill_member), HP_POP2(HP_party_fill_member), 3324 },
+{ HP_POP(party->sd_check), HP_POP2(HP_party_sd_check), 3326 },
+{ HP_POP(party->check_state), HP_POP2(HP_party_check_state), 3328 },
+{ HP_POP(party->create_booking_data), HP_POP2(HP_party_create_booking_data), 3330 },
+{ HP_POP(party->db_final), HP_POP2(HP_party_db_final), 3332 },
+/* path */
+{ HP_POP(path->blownpos), HP_POP2(HP_path_blownpos), 3334 },
+{ HP_POP(path->search), HP_POP2(HP_path_search), 3336 },
+{ HP_POP(path->search_long), HP_POP2(HP_path_search_long), 3338 },
+{ HP_POP(path->check_distance), HP_POP2(HP_path_check_distance), 3340 },
+{ HP_POP(path->distance), HP_POP2(HP_path_distance), 3342 },
+/* pc */
+{ HP_POP(pc->init), HP_POP2(HP_pc_init), 3344 },
+{ HP_POP(pc->final), HP_POP2(HP_pc_final), 3346 },
+{ HP_POP(pc->get_dummy_sd), HP_POP2(HP_pc_get_dummy_sd), 3348 },
+{ HP_POP(pc->class2idx), HP_POP2(HP_pc_class2idx), 3350 },
+{ HP_POP(pc->get_group_level), HP_POP2(HP_pc_get_group_level), 3352 },
+{ HP_POP(pc->can_give_items), HP_POP2(HP_pc_can_give_items), 3354 },
+{ HP_POP(pc->can_use_command), HP_POP2(HP_pc_can_use_command), 3356 },
+{ HP_POP(pc->has_permission), HP_POP2(HP_pc_has_permission), 3358 },
+{ HP_POP(pc->set_group), HP_POP2(HP_pc_set_group), 3360 },
+{ HP_POP(pc->should_log_commands), HP_POP2(HP_pc_should_log_commands), 3362 },
+{ HP_POP(pc->setrestartvalue), HP_POP2(HP_pc_setrestartvalue), 3364 },
+{ HP_POP(pc->makesavestatus), HP_POP2(HP_pc_makesavestatus), 3366 },
+{ HP_POP(pc->respawn), HP_POP2(HP_pc_respawn), 3368 },
+{ HP_POP(pc->setnewpc), HP_POP2(HP_pc_setnewpc), 3370 },
+{ HP_POP(pc->authok), HP_POP2(HP_pc_authok), 3372 },
+{ HP_POP(pc->authfail), HP_POP2(HP_pc_authfail), 3374 },
+{ HP_POP(pc->reg_received), HP_POP2(HP_pc_reg_received), 3376 },
+{ HP_POP(pc->isequip), HP_POP2(HP_pc_isequip), 3378 },
+{ HP_POP(pc->equippoint), HP_POP2(HP_pc_equippoint), 3380 },
+{ HP_POP(pc->setinventorydata), HP_POP2(HP_pc_setinventorydata), 3382 },
+{ HP_POP(pc->checkskill), HP_POP2(HP_pc_checkskill), 3384 },
+{ HP_POP(pc->checkskill2), HP_POP2(HP_pc_checkskill2), 3386 },
+{ HP_POP(pc->checkallowskill), HP_POP2(HP_pc_checkallowskill), 3388 },
+{ HP_POP(pc->checkequip), HP_POP2(HP_pc_checkequip), 3390 },
+{ HP_POP(pc->calc_skilltree), HP_POP2(HP_pc_calc_skilltree), 3392 },
+{ HP_POP(pc->calc_skilltree_normalize_job), HP_POP2(HP_pc_calc_skilltree_normalize_job), 3394 },
+{ HP_POP(pc->clean_skilltree), HP_POP2(HP_pc_clean_skilltree), 3396 },
+{ HP_POP(pc->setpos), HP_POP2(HP_pc_setpos), 3398 },
+{ HP_POP(pc->setsavepoint), HP_POP2(HP_pc_setsavepoint), 3400 },
+{ HP_POP(pc->randomwarp), HP_POP2(HP_pc_randomwarp), 3402 },
+{ HP_POP(pc->memo), HP_POP2(HP_pc_memo), 3404 },
+{ HP_POP(pc->checkadditem), HP_POP2(HP_pc_checkadditem), 3406 },
+{ HP_POP(pc->inventoryblank), HP_POP2(HP_pc_inventoryblank), 3408 },
+{ HP_POP(pc->search_inventory), HP_POP2(HP_pc_search_inventory), 3410 },
+{ HP_POP(pc->payzeny), HP_POP2(HP_pc_payzeny), 3412 },
+{ HP_POP(pc->additem), HP_POP2(HP_pc_additem), 3414 },
+{ HP_POP(pc->getzeny), HP_POP2(HP_pc_getzeny), 3416 },
+{ HP_POP(pc->delitem), HP_POP2(HP_pc_delitem), 3418 },
+{ HP_POP(pc->paycash), HP_POP2(HP_pc_paycash), 3420 },
+{ HP_POP(pc->getcash), HP_POP2(HP_pc_getcash), 3422 },
+{ HP_POP(pc->cart_additem), HP_POP2(HP_pc_cart_additem), 3424 },
+{ HP_POP(pc->cart_delitem), HP_POP2(HP_pc_cart_delitem), 3426 },
+{ HP_POP(pc->putitemtocart), HP_POP2(HP_pc_putitemtocart), 3428 },
+{ HP_POP(pc->getitemfromcart), HP_POP2(HP_pc_getitemfromcart), 3430 },
+{ HP_POP(pc->cartitem_amount), HP_POP2(HP_pc_cartitem_amount), 3432 },
+{ HP_POP(pc->takeitem), HP_POP2(HP_pc_takeitem), 3434 },
+{ HP_POP(pc->dropitem), HP_POP2(HP_pc_dropitem), 3436 },
+{ HP_POP(pc->isequipped), HP_POP2(HP_pc_isequipped), 3438 },
+{ HP_POP(pc->can_Adopt), HP_POP2(HP_pc_can_Adopt), 3440 },
+{ HP_POP(pc->adoption), HP_POP2(HP_pc_adoption), 3442 },
+{ HP_POP(pc->updateweightstatus), HP_POP2(HP_pc_updateweightstatus), 3444 },
+{ HP_POP(pc->addautobonus), HP_POP2(HP_pc_addautobonus), 3446 },
+{ HP_POP(pc->exeautobonus), HP_POP2(HP_pc_exeautobonus), 3448 },
+{ HP_POP(pc->endautobonus), HP_POP2(HP_pc_endautobonus), 3450 },
+{ HP_POP(pc->delautobonus), HP_POP2(HP_pc_delautobonus), 3452 },
+{ HP_POP(pc->bonus), HP_POP2(HP_pc_bonus), 3454 },
+{ HP_POP(pc->bonus2), HP_POP2(HP_pc_bonus2), 3456 },
+{ HP_POP(pc->bonus3), HP_POP2(HP_pc_bonus3), 3458 },
+{ HP_POP(pc->bonus4), HP_POP2(HP_pc_bonus4), 3460 },
+{ HP_POP(pc->bonus5), HP_POP2(HP_pc_bonus5), 3462 },
+{ HP_POP(pc->skill), HP_POP2(HP_pc_skill), 3464 },
+{ HP_POP(pc->insert_card), HP_POP2(HP_pc_insert_card), 3466 },
+{ HP_POP(pc->steal_item), HP_POP2(HP_pc_steal_item), 3468 },
+{ HP_POP(pc->steal_coin), HP_POP2(HP_pc_steal_coin), 3470 },
+{ HP_POP(pc->modifybuyvalue), HP_POP2(HP_pc_modifybuyvalue), 3472 },
+{ HP_POP(pc->modifysellvalue), HP_POP2(HP_pc_modifysellvalue), 3474 },
+{ HP_POP(pc->follow), HP_POP2(HP_pc_follow), 3476 },
+{ HP_POP(pc->stop_following), HP_POP2(HP_pc_stop_following), 3478 },
+{ HP_POP(pc->maxbaselv), HP_POP2(HP_pc_maxbaselv), 3480 },
+{ HP_POP(pc->maxjoblv), HP_POP2(HP_pc_maxjoblv), 3482 },
+{ HP_POP(pc->checkbaselevelup), HP_POP2(HP_pc_checkbaselevelup), 3484 },
+{ HP_POP(pc->checkjoblevelup), HP_POP2(HP_pc_checkjoblevelup), 3486 },
+{ HP_POP(pc->gainexp), HP_POP2(HP_pc_gainexp), 3488 },
+{ HP_POP(pc->nextbaseexp), HP_POP2(HP_pc_nextbaseexp), 3490 },
+{ HP_POP(pc->thisbaseexp), HP_POP2(HP_pc_thisbaseexp), 3492 },
+{ HP_POP(pc->nextjobexp), HP_POP2(HP_pc_nextjobexp), 3494 },
+{ HP_POP(pc->thisjobexp), HP_POP2(HP_pc_thisjobexp), 3496 },
+{ HP_POP(pc->gets_status_point), HP_POP2(HP_pc_gets_status_point), 3498 },
+{ HP_POP(pc->need_status_point), HP_POP2(HP_pc_need_status_point), 3500 },
+{ HP_POP(pc->statusup), HP_POP2(HP_pc_statusup), 3502 },
+{ HP_POP(pc->statusup2), HP_POP2(HP_pc_statusup2), 3504 },
+{ HP_POP(pc->skillup), HP_POP2(HP_pc_skillup), 3506 },
+{ HP_POP(pc->allskillup), HP_POP2(HP_pc_allskillup), 3508 },
+{ HP_POP(pc->resetlvl), HP_POP2(HP_pc_resetlvl), 3510 },
+{ HP_POP(pc->resetstate), HP_POP2(HP_pc_resetstate), 3512 },
+{ HP_POP(pc->resetskill), HP_POP2(HP_pc_resetskill), 3514 },
+{ HP_POP(pc->resetfeel), HP_POP2(HP_pc_resetfeel), 3516 },
+{ HP_POP(pc->resethate), HP_POP2(HP_pc_resethate), 3518 },
+{ HP_POP(pc->equipitem), HP_POP2(HP_pc_equipitem), 3520 },
+{ HP_POP(pc->unequipitem), HP_POP2(HP_pc_unequipitem), 3522 },
+{ HP_POP(pc->checkitem), HP_POP2(HP_pc_checkitem), 3524 },
+{ HP_POP(pc->useitem), HP_POP2(HP_pc_useitem), 3526 },
+{ HP_POP(pc->skillatk_bonus), HP_POP2(HP_pc_skillatk_bonus), 3528 },
+{ HP_POP(pc->skillheal_bonus), HP_POP2(HP_pc_skillheal_bonus), 3530 },
+{ HP_POP(pc->skillheal2_bonus), HP_POP2(HP_pc_skillheal2_bonus), 3532 },
+{ HP_POP(pc->damage), HP_POP2(HP_pc_damage), 3534 },
+{ HP_POP(pc->dead), HP_POP2(HP_pc_dead), 3536 },
+{ HP_POP(pc->revive), HP_POP2(HP_pc_revive), 3538 },
+{ HP_POP(pc->heal), HP_POP2(HP_pc_heal), 3540 },
+{ HP_POP(pc->itemheal), HP_POP2(HP_pc_itemheal), 3542 },
+{ HP_POP(pc->percentheal), HP_POP2(HP_pc_percentheal), 3544 },
+{ HP_POP(pc->jobchange), HP_POP2(HP_pc_jobchange), 3546 },
+{ HP_POP(pc->setoption), HP_POP2(HP_pc_setoption), 3548 },
+{ HP_POP(pc->setcart), HP_POP2(HP_pc_setcart), 3550 },
+{ HP_POP(pc->setfalcon), HP_POP2(HP_pc_setfalcon), 3552 },
+{ HP_POP(pc->setriding), HP_POP2(HP_pc_setriding), 3554 },
+{ HP_POP(pc->setmadogear), HP_POP2(HP_pc_setmadogear), 3556 },
+{ HP_POP(pc->changelook), HP_POP2(HP_pc_changelook), 3558 },
+{ HP_POP(pc->equiplookall), HP_POP2(HP_pc_equiplookall), 3560 },
+{ HP_POP(pc->readparam), HP_POP2(HP_pc_readparam), 3562 },
+{ HP_POP(pc->setparam), HP_POP2(HP_pc_setparam), 3564 },
+{ HP_POP(pc->readreg), HP_POP2(HP_pc_readreg), 3566 },
+{ HP_POP(pc->setreg), HP_POP2(HP_pc_setreg), 3568 },
+{ HP_POP(pc->readregstr), HP_POP2(HP_pc_readregstr), 3570 },
+{ HP_POP(pc->setregstr), HP_POP2(HP_pc_setregstr), 3572 },
+{ HP_POP(pc->readregistry), HP_POP2(HP_pc_readregistry), 3574 },
+{ HP_POP(pc->setregistry), HP_POP2(HP_pc_setregistry), 3576 },
+{ HP_POP(pc->readregistry_str), HP_POP2(HP_pc_readregistry_str), 3578 },
+{ HP_POP(pc->setregistry_str), HP_POP2(HP_pc_setregistry_str), 3580 },
+{ HP_POP(pc->addeventtimer), HP_POP2(HP_pc_addeventtimer), 3582 },
+{ HP_POP(pc->deleventtimer), HP_POP2(HP_pc_deleventtimer), 3584 },
+{ HP_POP(pc->cleareventtimer), HP_POP2(HP_pc_cleareventtimer), 3586 },
+{ HP_POP(pc->addeventtimercount), HP_POP2(HP_pc_addeventtimercount), 3588 },
+{ HP_POP(pc->calc_pvprank), HP_POP2(HP_pc_calc_pvprank), 3590 },
+{ HP_POP(pc->calc_pvprank_timer), HP_POP2(HP_pc_calc_pvprank_timer), 3592 },
+{ HP_POP(pc->ismarried), HP_POP2(HP_pc_ismarried), 3594 },
+{ HP_POP(pc->marriage), HP_POP2(HP_pc_marriage), 3596 },
+{ HP_POP(pc->divorce), HP_POP2(HP_pc_divorce), 3598 },
+{ HP_POP(pc->get_partner), HP_POP2(HP_pc_get_partner), 3600 },
+{ HP_POP(pc->get_father), HP_POP2(HP_pc_get_father), 3602 },
+{ HP_POP(pc->get_mother), HP_POP2(HP_pc_get_mother), 3604 },
+{ HP_POP(pc->get_child), HP_POP2(HP_pc_get_child), 3606 },
+{ HP_POP(pc->bleeding), HP_POP2(HP_pc_bleeding), 3608 },
+{ HP_POP(pc->regen), HP_POP2(HP_pc_regen), 3610 },
+{ HP_POP(pc->setstand), HP_POP2(HP_pc_setstand), 3612 },
+{ HP_POP(pc->candrop), HP_POP2(HP_pc_candrop), 3614 },
+{ HP_POP(pc->jobid2mapid), HP_POP2(HP_pc_jobid2mapid), 3616 },
+{ HP_POP(pc->mapid2jobid), HP_POP2(HP_pc_mapid2jobid), 3618 },
+{ HP_POP(pc->job_name), HP_POP2(HP_pc_job_name), 3620 },
+{ HP_POP(pc->setinvincibletimer), HP_POP2(HP_pc_setinvincibletimer), 3622 },
+{ HP_POP(pc->delinvincibletimer), HP_POP2(HP_pc_delinvincibletimer), 3624 },
+{ HP_POP(pc->addspiritball), HP_POP2(HP_pc_addspiritball), 3626 },
+{ HP_POP(pc->delspiritball), HP_POP2(HP_pc_delspiritball), 3628 },
+{ HP_POP(pc->addfame), HP_POP2(HP_pc_addfame), 3630 },
+{ HP_POP(pc->famerank), HP_POP2(HP_pc_famerank), 3632 },
+{ HP_POP(pc->set_hate_mob), HP_POP2(HP_pc_set_hate_mob), 3634 },
+{ HP_POP(pc->readdb), HP_POP2(HP_pc_readdb), 3636 },
+{ HP_POP(pc->map_day_timer), HP_POP2(HP_pc_map_day_timer), 3638 },
+{ HP_POP(pc->map_night_timer), HP_POP2(HP_pc_map_night_timer), 3640 },
+{ HP_POP(pc->inventory_rentals), HP_POP2(HP_pc_inventory_rentals), 3642 },
+{ HP_POP(pc->inventory_rental_clear), HP_POP2(HP_pc_inventory_rental_clear), 3644 },
+{ HP_POP(pc->inventory_rental_add), HP_POP2(HP_pc_inventory_rental_add), 3646 },
+{ HP_POP(pc->disguise), HP_POP2(HP_pc_disguise), 3648 },
+{ HP_POP(pc->isautolooting), HP_POP2(HP_pc_isautolooting), 3650 },
+{ HP_POP(pc->overheat), HP_POP2(HP_pc_overheat), 3652 },
+{ HP_POP(pc->banding), HP_POP2(HP_pc_banding), 3654 },
+{ HP_POP(pc->itemcd_do), HP_POP2(HP_pc_itemcd_do), 3656 },
+{ HP_POP(pc->load_combo), HP_POP2(HP_pc_load_combo), 3658 },
+{ HP_POP(pc->add_charm), HP_POP2(HP_pc_add_charm), 3660 },
+{ HP_POP(pc->del_charm), HP_POP2(HP_pc_del_charm), 3662 },
+{ HP_POP(pc->baselevelchanged), HP_POP2(HP_pc_baselevelchanged), 3664 },
+{ HP_POP(pc->level_penalty_mod), HP_POP2(HP_pc_level_penalty_mod), 3666 },
+{ HP_POP(pc->calc_skillpoint), HP_POP2(HP_pc_calc_skillpoint), 3668 },
+{ HP_POP(pc->invincible_timer), HP_POP2(HP_pc_invincible_timer), 3670 },
+{ HP_POP(pc->spiritball_timer), HP_POP2(HP_pc_spiritball_timer), 3672 },
+{ HP_POP(pc->check_banding), HP_POP2(HP_pc_check_banding), 3674 },
+{ HP_POP(pc->inventory_rental_end), HP_POP2(HP_pc_inventory_rental_end), 3676 },
+{ HP_POP(pc->check_skilltree), HP_POP2(HP_pc_check_skilltree), 3678 },
+{ HP_POP(pc->bonus_autospell), HP_POP2(HP_pc_bonus_autospell), 3680 },
+{ HP_POP(pc->bonus_autospell_onskill), HP_POP2(HP_pc_bonus_autospell_onskill), 3682 },
+{ HP_POP(pc->bonus_addeff), HP_POP2(HP_pc_bonus_addeff), 3684 },
+{ HP_POP(pc->bonus_addeff_onskill), HP_POP2(HP_pc_bonus_addeff_onskill), 3686 },
+{ HP_POP(pc->bonus_item_drop), HP_POP2(HP_pc_bonus_item_drop), 3688 },
+{ HP_POP(pc->calcexp), HP_POP2(HP_pc_calcexp), 3690 },
+{ HP_POP(pc->respawn_timer), HP_POP2(HP_pc_respawn_timer), 3692 },
+{ HP_POP(pc->jobchange_killclone), HP_POP2(HP_pc_jobchange_killclone), 3694 },
+{ HP_POP(pc->getstat), HP_POP2(HP_pc_getstat), 3696 },
+{ HP_POP(pc->setstat), HP_POP2(HP_pc_setstat), 3698 },
+{ HP_POP(pc->eventtimer), HP_POP2(HP_pc_eventtimer), 3700 },
+{ HP_POP(pc->daynight_timer_sub), HP_POP2(HP_pc_daynight_timer_sub), 3702 },
+{ HP_POP(pc->charm_timer), HP_POP2(HP_pc_charm_timer), 3704 },
+{ HP_POP(pc->readdb_levelpenalty), HP_POP2(HP_pc_readdb_levelpenalty), 3706 },
+{ HP_POP(pc->autosave), HP_POP2(HP_pc_autosave), 3708 },
+{ HP_POP(pc->follow_timer), HP_POP2(HP_pc_follow_timer), 3710 },
+{ HP_POP(pc->read_skill_tree), HP_POP2(HP_pc_read_skill_tree), 3712 },
+{ HP_POP(pc->isUseitem), HP_POP2(HP_pc_isUseitem), 3714 },
+{ HP_POP(pc->show_steal), HP_POP2(HP_pc_show_steal), 3716 },
+{ HP_POP(pc->checkcombo), HP_POP2(HP_pc_checkcombo), 3718 },
+{ HP_POP(pc->calcweapontype), HP_POP2(HP_pc_calcweapontype), 3720 },
+{ HP_POP(pc->removecombo), HP_POP2(HP_pc_removecombo), 3722 },
+/* pet */
+{ HP_POP(pet->init), HP_POP2(HP_pet_init), 3724 },
+{ HP_POP(pet->final), HP_POP2(HP_pet_final), 3726 },
+{ HP_POP(pet->hungry_val), HP_POP2(HP_pet_hungry_val), 3728 },
+{ HP_POP(pet->set_intimate), HP_POP2(HP_pet_set_intimate), 3730 },
+{ HP_POP(pet->create_egg), HP_POP2(HP_pet_create_egg), 3732 },
+{ HP_POP(pet->unlocktarget), HP_POP2(HP_pet_unlocktarget), 3734 },
+{ HP_POP(pet->attackskill), HP_POP2(HP_pet_attackskill), 3736 },
+{ HP_POP(pet->target_check), HP_POP2(HP_pet_target_check), 3738 },
+{ HP_POP(pet->sc_check), HP_POP2(HP_pet_sc_check), 3740 },
+{ HP_POP(pet->hungry), HP_POP2(HP_pet_hungry), 3742 },
+{ HP_POP(pet->search_petDB_index), HP_POP2(HP_pet_search_petDB_index), 3744 },
+{ HP_POP(pet->hungry_timer_delete), HP_POP2(HP_pet_hungry_timer_delete), 3746 },
+{ HP_POP(pet->performance), HP_POP2(HP_pet_performance), 3748 },
+{ HP_POP(pet->return_egg), HP_POP2(HP_pet_return_egg), 3750 },
+{ HP_POP(pet->data_init), HP_POP2(HP_pet_data_init), 3752 },
+{ HP_POP(pet->birth_process), HP_POP2(HP_pet_birth_process), 3754 },
+{ HP_POP(pet->recv_petdata), HP_POP2(HP_pet_recv_petdata), 3756 },
+{ HP_POP(pet->select_egg), HP_POP2(HP_pet_select_egg), 3758 },
+{ HP_POP(pet->catch_process1), HP_POP2(HP_pet_catch_process1), 3760 },
+{ HP_POP(pet->catch_process2), HP_POP2(HP_pet_catch_process2), 3762 },
+{ HP_POP(pet->get_egg), HP_POP2(HP_pet_get_egg), 3764 },
+{ HP_POP(pet->unequipitem), HP_POP2(HP_pet_unequipitem), 3766 },
+{ HP_POP(pet->food), HP_POP2(HP_pet_food), 3768 },
+{ HP_POP(pet->ai_sub_hard_lootsearch), HP_POP2(HP_pet_ai_sub_hard_lootsearch), 3770 },
+{ HP_POP(pet->menu), HP_POP2(HP_pet_menu), 3772 },
+{ HP_POP(pet->change_name), HP_POP2(HP_pet_change_name), 3774 },
+{ HP_POP(pet->change_name_ack), HP_POP2(HP_pet_change_name_ack), 3776 },
+{ HP_POP(pet->equipitem), HP_POP2(HP_pet_equipitem), 3778 },
+{ HP_POP(pet->randomwalk), HP_POP2(HP_pet_randomwalk), 3780 },
+{ HP_POP(pet->ai_sub_hard), HP_POP2(HP_pet_ai_sub_hard), 3782 },
+{ HP_POP(pet->ai_sub_foreachclient), HP_POP2(HP_pet_ai_sub_foreachclient), 3784 },
+{ HP_POP(pet->ai_hard), HP_POP2(HP_pet_ai_hard), 3786 },
+{ HP_POP(pet->delay_item_drop), HP_POP2(HP_pet_delay_item_drop), 3788 },
+{ HP_POP(pet->lootitem_drop), HP_POP2(HP_pet_lootitem_drop), 3790 },
+{ HP_POP(pet->skill_bonus_timer), HP_POP2(HP_pet_skill_bonus_timer), 3792 },
+{ HP_POP(pet->recovery_timer), HP_POP2(HP_pet_recovery_timer), 3794 },
+{ HP_POP(pet->heal_timer), HP_POP2(HP_pet_heal_timer), 3796 },
+{ HP_POP(pet->skill_support_timer), HP_POP2(HP_pet_skill_support_timer), 3798 },
+{ HP_POP(pet->read_db), HP_POP2(HP_pet_read_db), 3800 },
+/* quest */
+{ HP_POP(quest->init), HP_POP2(HP_quest_init), 3802 },
+{ HP_POP(quest->reload), HP_POP2(HP_quest_reload), 3804 },
+{ HP_POP(quest->search_db), HP_POP2(HP_quest_search_db), 3806 },
+{ HP_POP(quest->pc_login), HP_POP2(HP_quest_pc_login), 3808 },
+{ HP_POP(quest->add), HP_POP2(HP_quest_add), 3810 },
+{ HP_POP(quest->change), HP_POP2(HP_quest_change), 3812 },
+{ HP_POP(quest->delete), HP_POP2(HP_quest_delete), 3814 },
+{ HP_POP(quest->update_objective_sub), HP_POP2(HP_quest_update_objective_sub), 3816 },
+{ HP_POP(quest->update_objective), HP_POP2(HP_quest_update_objective), 3818 },
+{ HP_POP(quest->update_status), HP_POP2(HP_quest_update_status), 3820 },
+{ HP_POP(quest->check), HP_POP2(HP_quest_check), 3822 },
+{ HP_POP(quest->read_db), HP_POP2(HP_quest_read_db), 3824 },
+/* script */
+{ HP_POP(script->init), HP_POP2(HP_script_init), 3826 },
+{ HP_POP(script->final), HP_POP2(HP_script_final), 3828 },
+{ HP_POP(script->reload), HP_POP2(HP_script_reload), 3830 },
+{ HP_POP(script->parse), HP_POP2(HP_script_parse), 3832 },
+{ HP_POP(script->parse_builtin), HP_POP2(HP_script_parse_builtin), 3834 },
+{ HP_POP(script->parse_subexpr), HP_POP2(HP_script_parse_subexpr), 3836 },
+{ HP_POP(script->skip_space), HP_POP2(HP_script_skip_space), 3838 },
+{ HP_POP(script->error), HP_POP2(HP_script_error), 3840 },
+{ HP_POP(script->warning), HP_POP2(HP_script_warning), 3842 },
+{ HP_POP(script->addScript), HP_POP2(HP_script_addScript), 3844 },
+{ HP_POP(script->conv_num), HP_POP2(HP_script_conv_num), 3846 },
+{ HP_POP(script->conv_str), HP_POP2(HP_script_conv_str), 3848 },
+{ HP_POP(script->rid2sd), HP_POP2(HP_script_rid2sd), 3850 },
+{ HP_POP(script->detach_rid), HP_POP2(HP_script_detach_rid), 3852 },
+{ HP_POP(script->push_val), HP_POP2(HP_script_push_val), 3854 },
+{ HP_POP(script->get_val), HP_POP2(HP_script_get_val), 3856 },
+{ HP_POP(script->get_val2), HP_POP2(HP_script_get_val2), 3858 },
+{ HP_POP(script->push_str), HP_POP2(HP_script_push_str), 3860 },
+{ HP_POP(script->push_copy), HP_POP2(HP_script_push_copy), 3862 },
+{ HP_POP(script->pop_stack), HP_POP2(HP_script_pop_stack), 3864 },
+{ HP_POP(script->set_constant), HP_POP2(HP_script_set_constant), 3866 },
+{ HP_POP(script->set_constant2), HP_POP2(HP_script_set_constant2), 3868 },
+{ HP_POP(script->set_constant_force), HP_POP2(HP_script_set_constant_force), 3870 },
+{ HP_POP(script->get_constant), HP_POP2(HP_script_get_constant), 3872 },
+{ HP_POP(script->label_add), HP_POP2(HP_script_label_add), 3874 },
+{ HP_POP(script->run), HP_POP2(HP_script_run), 3876 },
+{ HP_POP(script->run_main), HP_POP2(HP_script_run_main), 3878 },
+{ HP_POP(script->run_timer), HP_POP2(HP_script_run_timer), 3880 },
+{ HP_POP(script->set_var), HP_POP2(HP_script_set_var), 3882 },
+{ HP_POP(script->stop_instances), HP_POP2(HP_script_stop_instances), 3884 },
+{ HP_POP(script->free_code), HP_POP2(HP_script_free_code), 3886 },
+{ HP_POP(script->free_vars), HP_POP2(HP_script_free_vars), 3888 },
+{ HP_POP(script->alloc_state), HP_POP2(HP_script_alloc_state), 3890 },
+{ HP_POP(script->free_state), HP_POP2(HP_script_free_state), 3892 },
+{ HP_POP(script->run_autobonus), HP_POP2(HP_script_run_autobonus), 3894 },
+{ HP_POP(script->cleararray_pc), HP_POP2(HP_script_cleararray_pc), 3896 },
+{ HP_POP(script->setarray_pc), HP_POP2(HP_script_setarray_pc), 3898 },
+{ HP_POP(script->config_read), HP_POP2(HP_script_config_read), 3900 },
+{ HP_POP(script->add_str), HP_POP2(HP_script_add_str), 3902 },
+{ HP_POP(script->get_str), HP_POP2(HP_script_get_str), 3904 },
+{ HP_POP(script->search_str), HP_POP2(HP_script_search_str), 3906 },
+{ HP_POP(script->setd_sub), HP_POP2(HP_script_setd_sub), 3908 },
+{ HP_POP(script->attach_state), HP_POP2(HP_script_attach_state), 3910 },
+{ HP_POP(script->queue), HP_POP2(HP_script_queue), 3912 },
+{ HP_POP(script->queue_add), HP_POP2(HP_script_queue_add), 3914 },
+{ HP_POP(script->queue_del), HP_POP2(HP_script_queue_del), 3916 },
+{ HP_POP(script->queue_remove), HP_POP2(HP_script_queue_remove), 3918 },
+{ HP_POP(script->queue_create), HP_POP2(HP_script_queue_create), 3920 },
+{ HP_POP(script->queue_clear), HP_POP2(HP_script_queue_clear), 3922 },
+{ HP_POP(script->parse_curly_close), HP_POP2(HP_script_parse_curly_close), 3924 },
+{ HP_POP(script->parse_syntax_close), HP_POP2(HP_script_parse_syntax_close), 3926 },
+{ HP_POP(script->parse_syntax_close_sub), HP_POP2(HP_script_parse_syntax_close_sub), 3928 },
+{ HP_POP(script->parse_syntax), HP_POP2(HP_script_parse_syntax), 3930 },
+{ HP_POP(script->get_com), HP_POP2(HP_script_get_com), 3932 },
+{ HP_POP(script->get_num), HP_POP2(HP_script_get_num), 3934 },
+{ HP_POP(script->op2name), HP_POP2(HP_script_op2name), 3936 },
+{ HP_POP(script->reportsrc), HP_POP2(HP_script_reportsrc), 3938 },
+{ HP_POP(script->reportdata), HP_POP2(HP_script_reportdata), 3940 },
+{ HP_POP(script->reportfunc), HP_POP2(HP_script_reportfunc), 3942 },
+{ HP_POP(script->disp_error_message2), HP_POP2(HP_script_disp_error_message2), 3944 },
+{ HP_POP(script->disp_warning_message), HP_POP2(HP_script_disp_warning_message), 3946 },
+{ HP_POP(script->check_event), HP_POP2(HP_script_check_event), 3948 },
+{ HP_POP(script->calc_hash), HP_POP2(HP_script_calc_hash), 3950 },
+{ HP_POP(script->addb), HP_POP2(HP_script_addb), 3952 },
+{ HP_POP(script->addc), HP_POP2(HP_script_addc), 3954 },
+{ HP_POP(script->addi), HP_POP2(HP_script_addi), 3956 },
+{ HP_POP(script->addl), HP_POP2(HP_script_addl), 3958 },
+{ HP_POP(script->set_label), HP_POP2(HP_script_set_label), 3960 },
+{ HP_POP(script->skip_word), HP_POP2(HP_script_skip_word), 3962 },
+{ HP_POP(script->add_word), HP_POP2(HP_script_add_word), 3964 },
+{ HP_POP(script->parse_callfunc), HP_POP2(HP_script_parse_callfunc), 3966 },
+{ HP_POP(script->parse_nextline), HP_POP2(HP_script_parse_nextline), 3968 },
+{ HP_POP(script->parse_variable), HP_POP2(HP_script_parse_variable), 3970 },
+{ HP_POP(script->parse_simpleexpr), HP_POP2(HP_script_parse_simpleexpr), 3972 },
+{ HP_POP(script->parse_expr), HP_POP2(HP_script_parse_expr), 3974 },
+{ HP_POP(script->parse_line), HP_POP2(HP_script_parse_line), 3976 },
+{ HP_POP(script->read_constdb), HP_POP2(HP_script_read_constdb), 3978 },
+{ HP_POP(script->print_line), HP_POP2(HP_script_print_line), 3980 },
+{ HP_POP(script->errorwarning_sub), HP_POP2(HP_script_errorwarning_sub), 3982 },
+{ HP_POP(script->set_reg), HP_POP2(HP_script_set_reg), 3984 },
+{ HP_POP(script->stack_expand), HP_POP2(HP_script_stack_expand), 3986 },
+{ HP_POP(script->push_retinfo), HP_POP2(HP_script_push_retinfo), 3988 },
+{ HP_POP(script->pop_val), HP_POP2(HP_script_pop_val), 3990 },
+{ HP_POP(script->op_3), HP_POP2(HP_script_op_3), 3992 },
+{ HP_POP(script->op_2str), HP_POP2(HP_script_op_2str), 3994 },
+{ HP_POP(script->op_2num), HP_POP2(HP_script_op_2num), 3996 },
+{ HP_POP(script->op_2), HP_POP2(HP_script_op_2), 3998 },
+{ HP_POP(script->op_1), HP_POP2(HP_script_op_1), 4000 },
+{ HP_POP(script->check_buildin_argtype), HP_POP2(HP_script_check_buildin_argtype), 4002 },
+{ HP_POP(script->detach_state), HP_POP2(HP_script_detach_state), 4004 },
+{ HP_POP(script->db_free_code_sub), HP_POP2(HP_script_db_free_code_sub), 4006 },
+{ HP_POP(script->add_autobonus), HP_POP2(HP_script_add_autobonus), 4008 },
+{ HP_POP(script->menu_countoptions), HP_POP2(HP_script_menu_countoptions), 4010 },
+{ HP_POP(script->buildin_areawarp_sub), HP_POP2(HP_script_buildin_areawarp_sub), 4012 },
+{ HP_POP(script->buildin_areapercentheal_sub), HP_POP2(HP_script_buildin_areapercentheal_sub), 4014 },
+{ HP_POP(script->getarraysize), HP_POP2(HP_script_getarraysize), 4016 },
+{ HP_POP(script->buildin_delitem_delete), HP_POP2(HP_script_buildin_delitem_delete), 4018 },
+{ HP_POP(script->buildin_delitem_search), HP_POP2(HP_script_buildin_delitem_search), 4020 },
+{ HP_POP(script->buildin_killmonster_sub_strip), HP_POP2(HP_script_buildin_killmonster_sub_strip), 4022 },
+{ HP_POP(script->buildin_killmonster_sub), HP_POP2(HP_script_buildin_killmonster_sub), 4024 },
+{ HP_POP(script->buildin_killmonsterall_sub_strip), HP_POP2(HP_script_buildin_killmonsterall_sub_strip), 4026 },
+{ HP_POP(script->buildin_killmonsterall_sub), HP_POP2(HP_script_buildin_killmonsterall_sub), 4028 },
+{ HP_POP(script->buildin_announce_sub), HP_POP2(HP_script_buildin_announce_sub), 4030 },
+{ HP_POP(script->buildin_getareausers_sub), HP_POP2(HP_script_buildin_getareausers_sub), 4032 },
+{ HP_POP(script->buildin_getareadropitem_sub), HP_POP2(HP_script_buildin_getareadropitem_sub), 4034 },
+{ HP_POP(script->mapflag_pvp_sub), HP_POP2(HP_script_mapflag_pvp_sub), 4036 },
+{ HP_POP(script->buildin_pvpoff_sub), HP_POP2(HP_script_buildin_pvpoff_sub), 4038 },
+{ HP_POP(script->buildin_maprespawnguildid_sub_pc), HP_POP2(HP_script_buildin_maprespawnguildid_sub_pc), 4040 },
+{ HP_POP(script->buildin_maprespawnguildid_sub_mob), HP_POP2(HP_script_buildin_maprespawnguildid_sub_mob), 4042 },
+{ HP_POP(script->buildin_mobcount_sub), HP_POP2(HP_script_buildin_mobcount_sub), 4044 },
+{ HP_POP(script->playBGM_sub), HP_POP2(HP_script_playBGM_sub), 4046 },
+{ HP_POP(script->playBGM_foreachpc_sub), HP_POP2(HP_script_playBGM_foreachpc_sub), 4048 },
+{ HP_POP(script->soundeffect_sub), HP_POP2(HP_script_soundeffect_sub), 4050 },
+{ HP_POP(script->buildin_query_sql_sub), HP_POP2(HP_script_buildin_query_sql_sub), 4052 },
+{ HP_POP(script->axtoi), HP_POP2(HP_script_axtoi), 4054 },
+{ HP_POP(script->buildin_instance_warpall_sub), HP_POP2(HP_script_buildin_instance_warpall_sub), 4056 },
+{ HP_POP(script->buildin_mobuseskill_sub), HP_POP2(HP_script_buildin_mobuseskill_sub), 4058 },
+{ HP_POP(script->cleanfloor_sub), HP_POP2(HP_script_cleanfloor_sub), 4060 },
+{ HP_POP(script->run_func), HP_POP2(HP_script_run_func), 4062 },
+/* searchstore */
+{ HP_POP(searchstore->open), HP_POP2(HP_searchstore_open), 4064 },
+{ HP_POP(searchstore->query), HP_POP2(HP_searchstore_query), 4066 },
+{ HP_POP(searchstore->querynext), HP_POP2(HP_searchstore_querynext), 4068 },
+{ HP_POP(searchstore->next), HP_POP2(HP_searchstore_next), 4070 },
+{ HP_POP(searchstore->clear), HP_POP2(HP_searchstore_clear), 4072 },
+{ HP_POP(searchstore->close), HP_POP2(HP_searchstore_close), 4074 },
+{ HP_POP(searchstore->click), HP_POP2(HP_searchstore_click), 4076 },
+{ HP_POP(searchstore->queryremote), HP_POP2(HP_searchstore_queryremote), 4078 },
+{ HP_POP(searchstore->clearremote), HP_POP2(HP_searchstore_clearremote), 4080 },
+{ HP_POP(searchstore->result), HP_POP2(HP_searchstore_result), 4082 },
+/* skill */
+{ HP_POP(skill->init), HP_POP2(HP_skill_init), 4084 },
+{ HP_POP(skill->final), HP_POP2(HP_skill_final), 4086 },
+{ HP_POP(skill->reload), HP_POP2(HP_skill_reload), 4088 },
+{ HP_POP(skill->read_db), HP_POP2(HP_skill_read_db), 4090 },
+{ HP_POP(skill->get_index), HP_POP2(HP_skill_get_index), 4092 },
+{ HP_POP(skill->get_type), HP_POP2(HP_skill_get_type), 4094 },
+{ HP_POP(skill->get_hit), HP_POP2(HP_skill_get_hit), 4096 },
+{ HP_POP(skill->get_inf), HP_POP2(HP_skill_get_inf), 4098 },
+{ HP_POP(skill->get_ele), HP_POP2(HP_skill_get_ele), 4100 },
+{ HP_POP(skill->get_nk), HP_POP2(HP_skill_get_nk), 4102 },
+{ HP_POP(skill->get_max), HP_POP2(HP_skill_get_max), 4104 },
+{ HP_POP(skill->get_range), HP_POP2(HP_skill_get_range), 4106 },
+{ HP_POP(skill->get_range2), HP_POP2(HP_skill_get_range2), 4108 },
+{ HP_POP(skill->get_splash), HP_POP2(HP_skill_get_splash), 4110 },
+{ HP_POP(skill->get_hp), HP_POP2(HP_skill_get_hp), 4112 },
+{ HP_POP(skill->get_mhp), HP_POP2(HP_skill_get_mhp), 4114 },
+{ HP_POP(skill->get_sp), HP_POP2(HP_skill_get_sp), 4116 },
+{ HP_POP(skill->get_state), HP_POP2(HP_skill_get_state), 4118 },
+{ HP_POP(skill->get_spiritball), HP_POP2(HP_skill_get_spiritball), 4120 },
+{ HP_POP(skill->get_zeny), HP_POP2(HP_skill_get_zeny), 4122 },
+{ HP_POP(skill->get_num), HP_POP2(HP_skill_get_num), 4124 },
+{ HP_POP(skill->get_cast), HP_POP2(HP_skill_get_cast), 4126 },
+{ HP_POP(skill->get_delay), HP_POP2(HP_skill_get_delay), 4128 },
+{ HP_POP(skill->get_walkdelay), HP_POP2(HP_skill_get_walkdelay), 4130 },
+{ HP_POP(skill->get_time), HP_POP2(HP_skill_get_time), 4132 },
+{ HP_POP(skill->get_time2), HP_POP2(HP_skill_get_time2), 4134 },
+{ HP_POP(skill->get_castnodex), HP_POP2(HP_skill_get_castnodex), 4136 },
+{ HP_POP(skill->get_delaynodex), HP_POP2(HP_skill_get_delaynodex), 4138 },
+{ HP_POP(skill->get_castdef), HP_POP2(HP_skill_get_castdef), 4140 },
+{ HP_POP(skill->get_weapontype), HP_POP2(HP_skill_get_weapontype), 4142 },
+{ HP_POP(skill->get_ammotype), HP_POP2(HP_skill_get_ammotype), 4144 },
+{ HP_POP(skill->get_ammo_qty), HP_POP2(HP_skill_get_ammo_qty), 4146 },
+{ HP_POP(skill->get_unit_id), HP_POP2(HP_skill_get_unit_id), 4148 },
+{ HP_POP(skill->get_inf2), HP_POP2(HP_skill_get_inf2), 4150 },
+{ HP_POP(skill->get_castcancel), HP_POP2(HP_skill_get_castcancel), 4152 },
+{ HP_POP(skill->get_maxcount), HP_POP2(HP_skill_get_maxcount), 4154 },
+{ HP_POP(skill->get_blewcount), HP_POP2(HP_skill_get_blewcount), 4156 },
+{ HP_POP(skill->get_unit_flag), HP_POP2(HP_skill_get_unit_flag), 4158 },
+{ HP_POP(skill->get_unit_target), HP_POP2(HP_skill_get_unit_target), 4160 },
+{ HP_POP(skill->get_unit_interval), HP_POP2(HP_skill_get_unit_interval), 4162 },
+{ HP_POP(skill->get_unit_bl_target), HP_POP2(HP_skill_get_unit_bl_target), 4164 },
+{ HP_POP(skill->get_unit_layout_type), HP_POP2(HP_skill_get_unit_layout_type), 4166 },
+{ HP_POP(skill->get_unit_range), HP_POP2(HP_skill_get_unit_range), 4168 },
+{ HP_POP(skill->get_cooldown), HP_POP2(HP_skill_get_cooldown), 4170 },
+{ HP_POP(skill->tree_get_max), HP_POP2(HP_skill_tree_get_max), 4172 },
+{ HP_POP(skill->get_name), HP_POP2(HP_skill_get_name), 4174 },
+{ HP_POP(skill->get_desc), HP_POP2(HP_skill_get_desc), 4176 },
+{ HP_POP(skill->chk), HP_POP2(HP_skill_chk), 4178 },
+{ HP_POP(skill->get_casttype), HP_POP2(HP_skill_get_casttype), 4180 },
+{ HP_POP(skill->get_casttype2), HP_POP2(HP_skill_get_casttype2), 4182 },
+{ HP_POP(skill->name2id), HP_POP2(HP_skill_name2id), 4184 },
+{ HP_POP(skill->isammotype), HP_POP2(HP_skill_isammotype), 4186 },
+{ HP_POP(skill->castend_id), HP_POP2(HP_skill_castend_id), 4188 },
+{ HP_POP(skill->castend_pos), HP_POP2(HP_skill_castend_pos), 4190 },
+{ HP_POP(skill->castend_map), HP_POP2(HP_skill_castend_map), 4192 },
+{ HP_POP(skill->cleartimerskill), HP_POP2(HP_skill_cleartimerskill), 4194 },
+{ HP_POP(skill->addtimerskill), HP_POP2(HP_skill_addtimerskill), 4196 },
+{ HP_POP(skill->additional_effect), HP_POP2(HP_skill_additional_effect), 4198 },
+{ HP_POP(skill->counter_additional_effect), HP_POP2(HP_skill_counter_additional_effect), 4200 },
+{ HP_POP(skill->blown), HP_POP2(HP_skill_blown), 4202 },
+{ HP_POP(skill->break_equip), HP_POP2(HP_skill_break_equip), 4204 },
+{ HP_POP(skill->strip_equip), HP_POP2(HP_skill_strip_equip), 4206 },
+{ HP_POP(skill->id2group), HP_POP2(HP_skill_id2group), 4208 },
+{ HP_POP(skill->unitsetting), HP_POP2(HP_skill_unitsetting), 4210 },
+{ HP_POP(skill->initunit), HP_POP2(HP_skill_initunit), 4212 },
+{ HP_POP(skill->delunit), HP_POP2(HP_skill_delunit), 4214 },
+{ HP_POP(skill->init_unitgroup), HP_POP2(HP_skill_init_unitgroup), 4216 },
+{ HP_POP(skill->del_unitgroup), HP_POP2(HP_skill_del_unitgroup), 4218 },
+{ HP_POP(skill->clear_unitgroup), HP_POP2(HP_skill_clear_unitgroup), 4220 },
+{ HP_POP(skill->clear_group), HP_POP2(HP_skill_clear_group), 4222 },
+{ HP_POP(skill->unit_onplace), HP_POP2(HP_skill_unit_onplace), 4224 },
+{ HP_POP(skill->unit_ondamaged), HP_POP2(HP_skill_unit_ondamaged), 4226 },
+{ HP_POP(skill->cast_fix), HP_POP2(HP_skill_cast_fix), 4228 },
+{ HP_POP(skill->cast_fix_sc), HP_POP2(HP_skill_cast_fix_sc), 4230 },
+{ HP_POP(skill->vf_cast_fix), HP_POP2(HP_skill_vf_cast_fix), 4232 },
+{ HP_POP(skill->delay_fix), HP_POP2(HP_skill_delay_fix), 4234 },
+{ HP_POP(skill->check_condition_castbegin), HP_POP2(HP_skill_check_condition_castbegin), 4236 },
+{ HP_POP(skill->check_condition_castend), HP_POP2(HP_skill_check_condition_castend), 4238 },
+{ HP_POP(skill->consume_requirement), HP_POP2(HP_skill_consume_requirement), 4240 },
+{ HP_POP(skill->get_requirement), HP_POP2(HP_skill_get_requirement), 4242 },
+{ HP_POP(skill->check_pc_partner), HP_POP2(HP_skill_check_pc_partner), 4244 },
+{ HP_POP(skill->unit_move), HP_POP2(HP_skill_unit_move), 4246 },
+{ HP_POP(skill->unit_onleft), HP_POP2(HP_skill_unit_onleft), 4248 },
+{ HP_POP(skill->unit_onout), HP_POP2(HP_skill_unit_onout), 4250 },
+{ HP_POP(skill->unit_move_unit_group), HP_POP2(HP_skill_unit_move_unit_group), 4252 },
+{ HP_POP(skill->sit), HP_POP2(HP_skill_sit), 4254 },
+{ HP_POP(skill->brandishspear), HP_POP2(HP_skill_brandishspear), 4256 },
+{ HP_POP(skill->repairweapon), HP_POP2(HP_skill_repairweapon), 4258 },
+{ HP_POP(skill->identify), HP_POP2(HP_skill_identify), 4260 },
+{ HP_POP(skill->weaponrefine), HP_POP2(HP_skill_weaponrefine), 4262 },
+{ HP_POP(skill->autospell), HP_POP2(HP_skill_autospell), 4264 },
+{ HP_POP(skill->calc_heal), HP_POP2(HP_skill_calc_heal), 4266 },
+{ HP_POP(skill->check_cloaking), HP_POP2(HP_skill_check_cloaking), 4268 },
+{ HP_POP(skill->enchant_elemental_end), HP_POP2(HP_skill_enchant_elemental_end), 4270 },
+{ HP_POP(skill->not_ok), HP_POP2(HP_skill_not_ok), 4272 },
+{ HP_POP(skill->not_ok_hom), HP_POP2(HP_skill_not_ok_hom), 4274 },
+{ HP_POP(skill->not_ok_mercenary), HP_POP2(HP_skill_not_ok_mercenary), 4276 },
+{ HP_POP(skill->chastle_mob_changetarget), HP_POP2(HP_skill_chastle_mob_changetarget), 4278 },
+{ HP_POP(skill->can_produce_mix), HP_POP2(HP_skill_can_produce_mix), 4280 },
+{ HP_POP(skill->produce_mix), HP_POP2(HP_skill_produce_mix), 4282 },
+{ HP_POP(skill->arrow_create), HP_POP2(HP_skill_arrow_create), 4284 },
+{ HP_POP(skill->castend_nodamage_id), HP_POP2(HP_skill_castend_nodamage_id), 4286 },
+{ HP_POP(skill->castend_damage_id), HP_POP2(HP_skill_castend_damage_id), 4288 },
+{ HP_POP(skill->castend_pos2), HP_POP2(HP_skill_castend_pos2), 4290 },
+{ HP_POP(skill->blockpc_start), HP_POP2(HP_skill_blockpc_start), 4292 },
+{ HP_POP(skill->blockhomun_start), HP_POP2(HP_skill_blockhomun_start), 4294 },
+{ HP_POP(skill->blockmerc_start), HP_POP2(HP_skill_blockmerc_start), 4296 },
+{ HP_POP(skill->attack), HP_POP2(HP_skill_attack), 4298 },
+{ HP_POP(skill->attack_area), HP_POP2(HP_skill_attack_area), 4300 },
+{ HP_POP(skill->area_sub), HP_POP2(HP_skill_area_sub), 4302 },
+{ HP_POP(skill->area_sub_count), HP_POP2(HP_skill_area_sub_count), 4304 },
+{ HP_POP(skill->check_unit_range), HP_POP2(HP_skill_check_unit_range), 4306 },
+{ HP_POP(skill->check_unit_range_sub), HP_POP2(HP_skill_check_unit_range_sub), 4308 },
+{ HP_POP(skill->check_unit_range2), HP_POP2(HP_skill_check_unit_range2), 4310 },
+{ HP_POP(skill->check_unit_range2_sub), HP_POP2(HP_skill_check_unit_range2_sub), 4312 },
+{ HP_POP(skill->toggle_magicpower), HP_POP2(HP_skill_toggle_magicpower), 4314 },
+{ HP_POP(skill->magic_reflect), HP_POP2(HP_skill_magic_reflect), 4316 },
+{ HP_POP(skill->onskillusage), HP_POP2(HP_skill_onskillusage), 4318 },
+{ HP_POP(skill->cell_overlap), HP_POP2(HP_skill_cell_overlap), 4320 },
+{ HP_POP(skill->timerskill), HP_POP2(HP_skill_timerskill), 4322 },
+{ HP_POP(skill->trap_splash), HP_POP2(HP_skill_trap_splash), 4324 },
+{ HP_POP(skill->check_condition_mercenary), HP_POP2(HP_skill_check_condition_mercenary), 4326 },
+{ HP_POP(skill->locate_element_field), HP_POP2(HP_skill_locate_element_field), 4328 },
+{ HP_POP(skill->graffitiremover), HP_POP2(HP_skill_graffitiremover), 4330 },
+{ HP_POP(skill->activate_reverberation), HP_POP2(HP_skill_activate_reverberation), 4332 },
+{ HP_POP(skill->dance_overlap_sub), HP_POP2(HP_skill_dance_overlap_sub), 4334 },
+{ HP_POP(skill->dance_overlap), HP_POP2(HP_skill_dance_overlap), 4336 },
+{ HP_POP(skill->get_unit_layout), HP_POP2(HP_skill_get_unit_layout), 4338 },
+{ HP_POP(skill->frostjoke_scream), HP_POP2(HP_skill_frostjoke_scream), 4340 },
+{ HP_POP(skill->greed), HP_POP2(HP_skill_greed), 4342 },
+{ HP_POP(skill->destroy_trap), HP_POP2(HP_skill_destroy_trap), 4344 },
+{ HP_POP(skill->icewall_block), HP_POP2(HP_skill_icewall_block), 4346 },
+{ HP_POP(skill->unitgrouptickset_search), HP_POP2(HP_skill_unitgrouptickset_search), 4348 },
+{ HP_POP(skill->dance_switch), HP_POP2(HP_skill_dance_switch), 4350 },
+{ HP_POP(skill->check_condition_char_sub), HP_POP2(HP_skill_check_condition_char_sub), 4352 },
+{ HP_POP(skill->check_condition_mob_master_sub), HP_POP2(HP_skill_check_condition_mob_master_sub), 4354 },
+{ HP_POP(skill->brandishspear_first), HP_POP2(HP_skill_brandishspear_first), 4356 },
+{ HP_POP(skill->brandishspear_dir), HP_POP2(HP_skill_brandishspear_dir), 4358 },
+{ HP_POP(skill->get_fixed_cast), HP_POP2(HP_skill_get_fixed_cast), 4360 },
+{ HP_POP(skill->sit_count), HP_POP2(HP_skill_sit_count), 4362 },
+{ HP_POP(skill->sit_in), HP_POP2(HP_skill_sit_in), 4364 },
+{ HP_POP(skill->sit_out), HP_POP2(HP_skill_sit_out), 4366 },
+{ HP_POP(skill->unitsetmapcell), HP_POP2(HP_skill_unitsetmapcell), 4368 },
+{ HP_POP(skill->unit_onplace_timer), HP_POP2(HP_skill_unit_onplace_timer), 4370 },
+{ HP_POP(skill->unit_effect), HP_POP2(HP_skill_unit_effect), 4372 },
+{ HP_POP(skill->unit_timer_sub_onplace), HP_POP2(HP_skill_unit_timer_sub_onplace), 4374 },
+{ HP_POP(skill->unit_move_sub), HP_POP2(HP_skill_unit_move_sub), 4376 },
+{ HP_POP(skill->blockpc_end), HP_POP2(HP_skill_blockpc_end), 4378 },
+{ HP_POP(skill->blockhomun_end), HP_POP2(HP_skill_blockhomun_end), 4380 },
+{ HP_POP(skill->blockmerc_end), HP_POP2(HP_skill_blockmerc_end), 4382 },
+{ HP_POP(skill->split_atoi), HP_POP2(HP_skill_split_atoi), 4384 },
+{ HP_POP(skill->unit_timer), HP_POP2(HP_skill_unit_timer), 4386 },
+{ HP_POP(skill->unit_timer_sub), HP_POP2(HP_skill_unit_timer_sub), 4388 },
+{ HP_POP(skill->init_unit_layout), HP_POP2(HP_skill_init_unit_layout), 4390 },
+{ HP_POP(skill->parse_row_skilldb), HP_POP2(HP_skill_parse_row_skilldb), 4392 },
+{ HP_POP(skill->parse_row_requiredb), HP_POP2(HP_skill_parse_row_requiredb), 4394 },
+{ HP_POP(skill->parse_row_castdb), HP_POP2(HP_skill_parse_row_castdb), 4396 },
+{ HP_POP(skill->parse_row_castnodexdb), HP_POP2(HP_skill_parse_row_castnodexdb), 4398 },
+{ HP_POP(skill->parse_row_unitdb), HP_POP2(HP_skill_parse_row_unitdb), 4400 },
+{ HP_POP(skill->parse_row_producedb), HP_POP2(HP_skill_parse_row_producedb), 4402 },
+{ HP_POP(skill->parse_row_createarrowdb), HP_POP2(HP_skill_parse_row_createarrowdb), 4404 },
+{ HP_POP(skill->parse_row_abradb), HP_POP2(HP_skill_parse_row_abradb), 4406 },
+{ HP_POP(skill->parse_row_spellbookdb), HP_POP2(HP_skill_parse_row_spellbookdb), 4408 },
+{ HP_POP(skill->parse_row_magicmushroomdb), HP_POP2(HP_skill_parse_row_magicmushroomdb), 4410 },
+{ HP_POP(skill->parse_row_reproducedb), HP_POP2(HP_skill_parse_row_reproducedb), 4412 },
+{ HP_POP(skill->parse_row_improvisedb), HP_POP2(HP_skill_parse_row_improvisedb), 4414 },
+{ HP_POP(skill->parse_row_changematerialdb), HP_POP2(HP_skill_parse_row_changematerialdb), 4416 },
+{ HP_POP(skill->usave_add), HP_POP2(HP_skill_usave_add), 4418 },
+{ HP_POP(skill->usave_trigger), HP_POP2(HP_skill_usave_trigger), 4420 },
+{ HP_POP(skill->cooldown_load), HP_POP2(HP_skill_cooldown_load), 4422 },
+{ HP_POP(skill->spellbook), HP_POP2(HP_skill_spellbook), 4424 },
+{ HP_POP(skill->block_check), HP_POP2(HP_skill_block_check), 4426 },
+{ HP_POP(skill->detonator), HP_POP2(HP_skill_detonator), 4428 },
+{ HP_POP(skill->check_camouflage), HP_POP2(HP_skill_check_camouflage), 4430 },
+{ HP_POP(skill->magicdecoy), HP_POP2(HP_skill_magicdecoy), 4432 },
+{ HP_POP(skill->poisoningweapon), HP_POP2(HP_skill_poisoningweapon), 4434 },
+{ HP_POP(skill->select_menu), HP_POP2(HP_skill_select_menu), 4436 },
+{ HP_POP(skill->elementalanalysis), HP_POP2(HP_skill_elementalanalysis), 4438 },
+{ HP_POP(skill->changematerial), HP_POP2(HP_skill_changematerial), 4440 },
+{ HP_POP(skill->get_elemental_type), HP_POP2(HP_skill_get_elemental_type), 4442 },
+{ HP_POP(skill->cooldown_save), HP_POP2(HP_skill_cooldown_save), 4444 },
+{ HP_POP(skill->maelstrom_suction), HP_POP2(HP_skill_maelstrom_suction), 4446 },
+{ HP_POP(skill->get_new_group_id), HP_POP2(HP_skill_get_new_group_id), 4448 },
+/* status */
+{ HP_POP(status->init), HP_POP2(HP_status_init), 4450 },
+{ HP_POP(status->final), HP_POP2(HP_status_final), 4452 },
+{ HP_POP(status->get_refine_chance), HP_POP2(HP_status_get_refine_chance), 4454 },
+{ HP_POP(status->skill2sc), HP_POP2(HP_status_skill2sc), 4456 },
+{ HP_POP(status->sc2skill), HP_POP2(HP_status_sc2skill), 4458 },
+{ HP_POP(status->sc2scb_flag), HP_POP2(HP_status_sc2scb_flag), 4460 },
+{ HP_POP(status->type2relevant_bl_types), HP_POP2(HP_status_type2relevant_bl_types), 4462 },
+{ HP_POP(status->get_sc_type), HP_POP2(HP_status_get_sc_type), 4464 },
+{ HP_POP(status->damage), HP_POP2(HP_status_damage), 4466 },
+{ HP_POP(status->charge), HP_POP2(HP_status_charge), 4468 },
+{ HP_POP(status->percent_change), HP_POP2(HP_status_percent_change), 4470 },
+{ HP_POP(status->set_hp), HP_POP2(HP_status_set_hp), 4472 },
+{ HP_POP(status->set_sp), HP_POP2(HP_status_set_sp), 4474 },
+{ HP_POP(status->heal), HP_POP2(HP_status_heal), 4476 },
+{ HP_POP(status->revive), HP_POP2(HP_status_revive), 4478 },
+{ HP_POP(status->get_regen_data), HP_POP2(HP_status_get_regen_data), 4480 },
+{ HP_POP(status->get_status_data), HP_POP2(HP_status_get_status_data), 4482 },
+{ HP_POP(status->get_base_status), HP_POP2(HP_status_get_base_status), 4484 },
+{ HP_POP(status->get_name), HP_POP2(HP_status_get_name), 4486 },
+{ HP_POP(status->get_class), HP_POP2(HP_status_get_class), 4488 },
+{ HP_POP(status->get_lv), HP_POP2(HP_status_get_lv), 4490 },
+{ HP_POP(status->get_def), HP_POP2(HP_status_get_def), 4492 },
+{ HP_POP(status->get_speed), HP_POP2(HP_status_get_speed), 4494 },
+{ HP_POP(status->calc_attack_element), HP_POP2(HP_status_calc_attack_element), 4496 },
+{ HP_POP(status->get_party_id), HP_POP2(HP_status_get_party_id), 4498 },
+{ HP_POP(status->get_guild_id), HP_POP2(HP_status_get_guild_id), 4500 },
+{ HP_POP(status->get_emblem_id), HP_POP2(HP_status_get_emblem_id), 4502 },
+{ HP_POP(status->get_mexp), HP_POP2(HP_status_get_mexp), 4504 },
+{ HP_POP(status->get_race2), HP_POP2(HP_status_get_race2), 4506 },
+{ HP_POP(status->get_viewdata), HP_POP2(HP_status_get_viewdata), 4508 },
+{ HP_POP(status->set_viewdata), HP_POP2(HP_status_set_viewdata), 4510 },
+{ HP_POP(status->change_init), HP_POP2(HP_status_change_init), 4512 },
+{ HP_POP(status->get_sc), HP_POP2(HP_status_get_sc), 4514 },
+{ HP_POP(status->isdead), HP_POP2(HP_status_isdead), 4516 },
+{ HP_POP(status->isimmune), HP_POP2(HP_status_isimmune), 4518 },
+{ HP_POP(status->get_sc_def), HP_POP2(HP_status_get_sc_def), 4520 },
+{ HP_POP(status->change_start), HP_POP2(HP_status_change_start), 4522 },
+{ HP_POP(status->change_end_), HP_POP2(HP_status_change_end_), 4524 },
+{ HP_POP(status->kaahi_heal_timer), HP_POP2(HP_status_kaahi_heal_timer), 4526 },
+{ HP_POP(status->change_timer), HP_POP2(HP_status_change_timer), 4528 },
+{ HP_POP(status->change_timer_sub), HP_POP2(HP_status_change_timer_sub), 4530 },
+{ HP_POP(status->change_clear), HP_POP2(HP_status_change_clear), 4532 },
+{ HP_POP(status->change_clear_buffs), HP_POP2(HP_status_change_clear_buffs), 4534 },
+{ HP_POP(status->calc_bl_), HP_POP2(HP_status_calc_bl_), 4536 },
+{ HP_POP(status->calc_mob_), HP_POP2(HP_status_calc_mob_), 4538 },
+{ HP_POP(status->calc_pet_), HP_POP2(HP_status_calc_pet_), 4540 },
+{ HP_POP(status->calc_pc_), HP_POP2(HP_status_calc_pc_), 4542 },
+{ HP_POP(status->calc_homunculus_), HP_POP2(HP_status_calc_homunculus_), 4544 },
+{ HP_POP(status->calc_mercenary_), HP_POP2(HP_status_calc_mercenary_), 4546 },
+{ HP_POP(status->calc_elemental_), HP_POP2(HP_status_calc_elemental_), 4548 },
+{ HP_POP(status->calc_misc), HP_POP2(HP_status_calc_misc), 4550 },
+{ HP_POP(status->calc_regen), HP_POP2(HP_status_calc_regen), 4552 },
+{ HP_POP(status->calc_regen_rate), HP_POP2(HP_status_calc_regen_rate), 4554 },
+{ HP_POP(status->check_skilluse), HP_POP2(HP_status_check_skilluse), 4556 },
+{ HP_POP(status->check_visibility), HP_POP2(HP_status_check_visibility), 4558 },
+{ HP_POP(status->change_spread), HP_POP2(HP_status_change_spread), 4560 },
+{ HP_POP(status->calc_def), HP_POP2(HP_status_calc_def), 4562 },
+{ HP_POP(status->calc_def2), HP_POP2(HP_status_calc_def2), 4564 },
+{ HP_POP(status->calc_mdef), HP_POP2(HP_status_calc_mdef), 4566 },
+{ HP_POP(status->calc_mdef2), HP_POP2(HP_status_calc_mdef2), 4568 },
+{ HP_POP(status->calc_batk), HP_POP2(HP_status_calc_batk), 4570 },
+{ HP_POP(status->get_total_mdef), HP_POP2(HP_status_get_total_mdef), 4572 },
+{ HP_POP(status->get_total_def), HP_POP2(HP_status_get_total_def), 4574 },
+{ HP_POP(status->get_matk), HP_POP2(HP_status_get_matk), 4576 },
+{ HP_POP(status->readdb), HP_POP2(HP_status_readdb), 4578 },
+{ HP_POP(status->initChangeTables), HP_POP2(HP_status_initChangeTables), 4580 },
+{ HP_POP(status->initDummyData), HP_POP2(HP_status_initDummyData), 4582 },
+{ HP_POP(status->base_amotion_pc), HP_POP2(HP_status_base_amotion_pc), 4584 },
+{ HP_POP(status->base_atk), HP_POP2(HP_status_base_atk), 4586 },
+{ HP_POP(status->calc_sigma), HP_POP2(HP_status_calc_sigma), 4588 },
+{ HP_POP(status->base_pc_maxhp), HP_POP2(HP_status_base_pc_maxhp), 4590 },
+{ HP_POP(status->base_pc_maxsp), HP_POP2(HP_status_base_pc_maxsp), 4592 },
+{ HP_POP(status->calc_npc_), HP_POP2(HP_status_calc_npc_), 4594 },
+{ HP_POP(status->calc_str), HP_POP2(HP_status_calc_str), 4596 },
+{ HP_POP(status->calc_agi), HP_POP2(HP_status_calc_agi), 4598 },
+{ HP_POP(status->calc_vit), HP_POP2(HP_status_calc_vit), 4600 },
+{ HP_POP(status->calc_int), HP_POP2(HP_status_calc_int), 4602 },
+{ HP_POP(status->calc_dex), HP_POP2(HP_status_calc_dex), 4604 },
+{ HP_POP(status->calc_luk), HP_POP2(HP_status_calc_luk), 4606 },
+{ HP_POP(status->calc_watk), HP_POP2(HP_status_calc_watk), 4608 },
+{ HP_POP(status->calc_matk), HP_POP2(HP_status_calc_matk), 4610 },
+{ HP_POP(status->calc_hit), HP_POP2(HP_status_calc_hit), 4612 },
+{ HP_POP(status->calc_critical), HP_POP2(HP_status_calc_critical), 4614 },
+{ HP_POP(status->calc_flee), HP_POP2(HP_status_calc_flee), 4616 },
+{ HP_POP(status->calc_flee2), HP_POP2(HP_status_calc_flee2), 4618 },
+{ HP_POP(status->calc_speed), HP_POP2(HP_status_calc_speed), 4620 },
+{ HP_POP(status->calc_aspd_rate), HP_POP2(HP_status_calc_aspd_rate), 4622 },
+{ HP_POP(status->calc_dmotion), HP_POP2(HP_status_calc_dmotion), 4624 },
+{ HP_POP(status->calc_fix_aspd), HP_POP2(HP_status_calc_fix_aspd), 4626 },
+{ HP_POP(status->calc_maxhp), HP_POP2(HP_status_calc_maxhp), 4628 },
+{ HP_POP(status->calc_maxsp), HP_POP2(HP_status_calc_maxsp), 4630 },
+{ HP_POP(status->calc_element), HP_POP2(HP_status_calc_element), 4632 },
+{ HP_POP(status->calc_element_lv), HP_POP2(HP_status_calc_element_lv), 4634 },
+{ HP_POP(status->calc_mode), HP_POP2(HP_status_calc_mode), 4636 },
+{ HP_POP(status->calc_bl_main), HP_POP2(HP_status_calc_bl_main), 4638 },
+{ HP_POP(status->display_add), HP_POP2(HP_status_display_add), 4640 },
+{ HP_POP(status->display_remove), HP_POP2(HP_status_display_remove), 4642 },
+{ HP_POP(status->natural_heal), HP_POP2(HP_status_natural_heal), 4644 },
+{ HP_POP(status->natural_heal_timer), HP_POP2(HP_status_natural_heal_timer), 4646 },
+{ HP_POP(status->readdb_job1), HP_POP2(HP_status_readdb_job1), 4648 },
+{ HP_POP(status->readdb_job2), HP_POP2(HP_status_readdb_job2), 4650 },
+{ HP_POP(status->readdb_sizefix), HP_POP2(HP_status_readdb_sizefix), 4652 },
+{ HP_POP(status->readdb_refine), HP_POP2(HP_status_readdb_refine), 4654 },
+{ HP_POP(status->readdb_scconfig), HP_POP2(HP_status_readdb_scconfig), 4656 },
+/* storage */
+{ HP_POP(storage->reconnect), HP_POP2(HP_storage_reconnect), 4658 },
+{ HP_POP(storage->delitem), HP_POP2(HP_storage_delitem), 4660 },
+{ HP_POP(storage->open), HP_POP2(HP_storage_open), 4662 },
+{ HP_POP(storage->add), HP_POP2(HP_storage_add), 4664 },
+{ HP_POP(storage->get), HP_POP2(HP_storage_get), 4666 },
+{ HP_POP(storage->additem), HP_POP2(HP_storage_additem), 4668 },
+{ HP_POP(storage->addfromcart), HP_POP2(HP_storage_addfromcart), 4670 },
+{ HP_POP(storage->gettocart), HP_POP2(HP_storage_gettocart), 4672 },
+{ HP_POP(storage->close), HP_POP2(HP_storage_close), 4674 },
+{ HP_POP(storage->pc_quit), HP_POP2(HP_storage_pc_quit), 4676 },
+{ HP_POP(storage->comp_item), HP_POP2(HP_storage_comp_item), 4678 },
+{ HP_POP(storage->sortitem), HP_POP2(HP_storage_sortitem), 4680 },
+{ HP_POP(storage->reconnect_sub), HP_POP2(HP_storage_reconnect_sub), 4682 },
+/* trade */
+{ HP_POP(trade->request), HP_POP2(HP_trade_request), 4684 },
+{ HP_POP(trade->ack), HP_POP2(HP_trade_ack), 4686 },
+{ HP_POP(trade->check_impossible), HP_POP2(HP_trade_check_impossible), 4688 },
+{ HP_POP(trade->check), HP_POP2(HP_trade_check), 4690 },
+{ HP_POP(trade->additem), HP_POP2(HP_trade_additem), 4692 },
+{ HP_POP(trade->addzeny), HP_POP2(HP_trade_addzeny), 4694 },
+{ HP_POP(trade->ok), HP_POP2(HP_trade_ok), 4696 },
+{ HP_POP(trade->cancel), HP_POP2(HP_trade_cancel), 4698 },
+{ HP_POP(trade->commit), HP_POP2(HP_trade_commit), 4700 },
+/* unit */
+{ HP_POP(unit->init), HP_POP2(HP_unit_init), 4702 },
+{ HP_POP(unit->final), HP_POP2(HP_unit_final), 4704 },
+{ HP_POP(unit->bl2ud), HP_POP2(HP_unit_bl2ud), 4706 },
+{ HP_POP(unit->bl2ud2), HP_POP2(HP_unit_bl2ud2), 4708 },
+{ HP_POP(unit->attack_timer), HP_POP2(HP_unit_attack_timer), 4710 },
+{ HP_POP(unit->walktoxy_timer), HP_POP2(HP_unit_walktoxy_timer), 4712 },
+{ HP_POP(unit->walktoxy_sub), HP_POP2(HP_unit_walktoxy_sub), 4714 },
+{ HP_POP(unit->delay_walktoxy_timer), HP_POP2(HP_unit_delay_walktoxy_timer), 4716 },
+{ HP_POP(unit->walktoxy), HP_POP2(HP_unit_walktoxy), 4718 },
+{ HP_POP(unit->walktobl_sub), HP_POP2(HP_unit_walktobl_sub), 4720 },
+{ HP_POP(unit->walktobl), HP_POP2(HP_unit_walktobl), 4722 },
+{ HP_POP(unit->run), HP_POP2(HP_unit_run), 4724 },
+{ HP_POP(unit->wugdash), HP_POP2(HP_unit_wugdash), 4726 },
+{ HP_POP(unit->escape), HP_POP2(HP_unit_escape), 4728 },
+{ HP_POP(unit->movepos), HP_POP2(HP_unit_movepos), 4730 },
+{ HP_POP(unit->setdir), HP_POP2(HP_unit_setdir), 4732 },
+{ HP_POP(unit->getdir), HP_POP2(HP_unit_getdir), 4734 },
+{ HP_POP(unit->blown), HP_POP2(HP_unit_blown), 4736 },
+{ HP_POP(unit->warp), HP_POP2(HP_unit_warp), 4738 },
+{ HP_POP(unit->stop_walking), HP_POP2(HP_unit_stop_walking), 4740 },
+{ HP_POP(unit->skilluse_id), HP_POP2(HP_unit_skilluse_id), 4742 },
+{ HP_POP(unit->is_walking), HP_POP2(HP_unit_is_walking), 4744 },
+{ HP_POP(unit->can_move), HP_POP2(HP_unit_can_move), 4746 },
+{ HP_POP(unit->resume_running), HP_POP2(HP_unit_resume_running), 4748 },
+{ HP_POP(unit->set_walkdelay), HP_POP2(HP_unit_set_walkdelay), 4750 },
+{ HP_POP(unit->skilluse_id2), HP_POP2(HP_unit_skilluse_id2), 4752 },
+{ HP_POP(unit->skilluse_pos), HP_POP2(HP_unit_skilluse_pos), 4754 },
+{ HP_POP(unit->skilluse_pos2), HP_POP2(HP_unit_skilluse_pos2), 4756 },
+{ HP_POP(unit->set_target), HP_POP2(HP_unit_set_target), 4758 },
+{ HP_POP(unit->stop_attack), HP_POP2(HP_unit_stop_attack), 4760 },
+{ HP_POP(unit->unattackable), HP_POP2(HP_unit_unattackable), 4762 },
+{ HP_POP(unit->attack), HP_POP2(HP_unit_attack), 4764 },
+{ HP_POP(unit->cancel_combo), HP_POP2(HP_unit_cancel_combo), 4766 },
+{ HP_POP(unit->can_reach_pos), HP_POP2(HP_unit_can_reach_pos), 4768 },
+{ HP_POP(unit->can_reach_bl), HP_POP2(HP_unit_can_reach_bl), 4770 },
+{ HP_POP(unit->calc_pos), HP_POP2(HP_unit_calc_pos), 4772 },
+{ HP_POP(unit->attack_timer_sub), HP_POP2(HP_unit_attack_timer_sub), 4774 },
+{ HP_POP(unit->skillcastcancel), HP_POP2(HP_unit_skillcastcancel), 4776 },
+{ HP_POP(unit->dataset), HP_POP2(HP_unit_dataset), 4778 },
+{ HP_POP(unit->counttargeted), HP_POP2(HP_unit_counttargeted), 4780 },
+{ HP_POP(unit->fixdamage), HP_POP2(HP_unit_fixdamage), 4782 },
+{ HP_POP(unit->changeviewsize), HP_POP2(HP_unit_changeviewsize), 4784 },
+{ HP_POP(unit->remove_map), HP_POP2(HP_unit_remove_map), 4786 },
+{ HP_POP(unit->remove_map_pc), HP_POP2(HP_unit_remove_map_pc), 4788 },
+{ HP_POP(unit->free_pc), HP_POP2(HP_unit_free_pc), 4790 },
+{ HP_POP(unit->free), HP_POP2(HP_unit_free), 4792 },
+/* vending */
+{ HP_POP(vending->init), HP_POP2(HP_vending_init), 4794 },
+{ HP_POP(vending->final), HP_POP2(HP_vending_final), 4796 },
+{ HP_POP(vending->close), HP_POP2(HP_vending_close), 4798 },
+{ HP_POP(vending->open), HP_POP2(HP_vending_open), 4800 },
+{ HP_POP(vending->list), HP_POP2(HP_vending_list), 4802 },
+{ HP_POP(vending->purchase), HP_POP2(HP_vending_purchase), 4804 },
+{ HP_POP(vending->search), HP_POP2(HP_vending_search), 4806 },
+{ HP_POP(vending->searchall), HP_POP2(HP_vending_searchall), 4808 },
+};
+int HookingPointsLenMax = 41;
diff --git a/src/plugins/HPMHooking/HPMHooking.Hooks.inc b/src/plugins/HPMHooking/HPMHooking.Hooks.inc
new file mode 100644
index 000000000..ce8e3b4b1
--- /dev/null
+++ b/src/plugins/HPMHooking/HPMHooking.Hooks.inc
@@ -0,0 +1,63639 @@
+/* atcommand */
+void HP_atcommand_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.init();
+	}
+	if( HPMHooks.count.HP_atcommand_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_atcommand_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.final();
+	}
+	if( HPMHooks.count.HP_atcommand_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+bool HP_atcommand_parse(const int fd, struct map_session_data *sd, const char *message, int type) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_atcommand_parse_pre ) {
+		bool (*preHookFunc) (const int *fd, struct map_session_data *sd, const char *message, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_parse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_parse_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd, sd, message, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.parse(fd, sd, message, type);
+	}
+	if( HPMHooks.count.HP_atcommand_parse_post ) {
+		bool (*postHookFunc) (bool retVal___, const int *fd, struct map_session_data *sd, const char *message, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_parse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_parse_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd, sd, message, &type);
+		}
+	}
+	return retVal___;
+}
+bool HP_atcommand_create(char *name, AtCommandFunc func) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_atcommand_create_pre ) {
+		bool (*preHookFunc) (char *name, AtCommandFunc *func);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_create_pre[hIndex].func;
+			retVal___ = preHookFunc(name, &func);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.create(name, func);
+	}
+	if( HPMHooks.count.HP_atcommand_create_post ) {
+		bool (*postHookFunc) (bool retVal___, char *name, AtCommandFunc *func);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, &func);
+		}
+	}
+	return retVal___;
+}
+bool HP_atcommand_can_use(struct map_session_data *sd, const char *command) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_atcommand_can_use_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, const char *command);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_can_use_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, command);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.can_use(sd, command);
+	}
+	if( HPMHooks.count.HP_atcommand_can_use_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *command);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_can_use_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, command);
+		}
+	}
+	return retVal___;
+}
+bool HP_atcommand_can_use2(struct map_session_data *sd, const char *command, AtCommandType type) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_atcommand_can_use2_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, const char *command, AtCommandType *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_can_use2_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, command, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.can_use2(sd, command, type);
+	}
+	if( HPMHooks.count.HP_atcommand_can_use2_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *command, AtCommandType *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_can_use2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, command, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_atcommand_load_groups(GroupSettings **groups, config_setting_t **commands_, size_t sz) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_load_groups_pre ) {
+		void (*preHookFunc) (GroupSettings **groups, config_setting_t **commands_, size_t *sz);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_load_groups_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_load_groups_pre[hIndex].func;
+			preHookFunc(groups, commands_, &sz);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.load_groups(groups, commands_, sz);
+	}
+	if( HPMHooks.count.HP_atcommand_load_groups_post ) {
+		void (*postHookFunc) (GroupSettings **groups, config_setting_t **commands_, size_t *sz);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_load_groups_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_load_groups_post[hIndex].func;
+			postHookFunc(groups, commands_, &sz);
+		}
+	}
+	return;
+}
+AtCommandInfo* HP_atcommand_exists(const char *name) {
+	int hIndex = 0;
+	AtCommandInfo* retVal___ = NULL;
+	if( HPMHooks.count.HP_atcommand_exists_pre ) {
+		AtCommandInfo* (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exists_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_exists_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.exists(name);
+	}
+	if( HPMHooks.count.HP_atcommand_exists_post ) {
+		AtCommandInfo* (*postHookFunc) (AtCommandInfo* retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exists_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_exists_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+int HP_atcommand_msg_read(const char *cfgName) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_atcommand_msg_read_pre ) {
+		int (*preHookFunc) (const char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_msg_read_pre[hIndex].func;
+			retVal___ = preHookFunc(cfgName);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.msg_read(cfgName);
+	}
+	if( HPMHooks.count.HP_atcommand_msg_read_post ) {
+		int (*postHookFunc) (int retVal___, const char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_msg_read_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cfgName);
+		}
+	}
+	return retVal___;
+}
+void HP_atcommand_final_msg(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_final_msg_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_final_msg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_final_msg_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.final_msg();
+	}
+	if( HPMHooks.count.HP_atcommand_final_msg_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_final_msg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_final_msg_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct atcmd_binding_data* HP_atcommand_get_bind_byname(const char *name) {
+	int hIndex = 0;
+	struct atcmd_binding_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_atcommand_get_bind_byname_pre ) {
+		struct atcmd_binding_data* (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_bind_byname_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_get_bind_byname_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.get_bind_byname(name);
+	}
+	if( HPMHooks.count.HP_atcommand_get_bind_byname_post ) {
+		struct atcmd_binding_data* (*postHookFunc) (struct atcmd_binding_data* retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_bind_byname_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_get_bind_byname_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+AtCommandInfo* HP_atcommand_get_info_byname(const char *name) {
+	int hIndex = 0;
+	AtCommandInfo* retVal___ = NULL;
+	if( HPMHooks.count.HP_atcommand_get_info_byname_pre ) {
+		AtCommandInfo* (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_info_byname_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_get_info_byname_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.get_info_byname(name);
+	}
+	if( HPMHooks.count.HP_atcommand_get_info_byname_post ) {
+		AtCommandInfo* (*postHookFunc) (AtCommandInfo* retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_info_byname_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_get_info_byname_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+const char* HP_atcommand_check_alias(const char *aliasname) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_atcommand_check_alias_pre ) {
+		const char* (*preHookFunc) (const char *aliasname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_check_alias_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_check_alias_pre[hIndex].func;
+			retVal___ = preHookFunc(aliasname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.atcommand.check_alias(aliasname);
+	}
+	if( HPMHooks.count.HP_atcommand_check_alias_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *aliasname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_check_alias_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_check_alias_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, aliasname);
+		}
+	}
+	return retVal___;
+}
+void HP_atcommand_get_suggestions(struct map_session_data *sd, const char *name, bool is_atcmd_cmd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_get_suggestions_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *name, bool *is_atcmd_cmd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_suggestions_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_get_suggestions_pre[hIndex].func;
+			preHookFunc(sd, name, &is_atcmd_cmd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.get_suggestions(sd, name, is_atcmd_cmd);
+	}
+	if( HPMHooks.count.HP_atcommand_get_suggestions_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *name, bool *is_atcmd_cmd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_suggestions_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_get_suggestions_post[hIndex].func;
+			postHookFunc(sd, name, &is_atcmd_cmd);
+		}
+	}
+	return;
+}
+void HP_atcommand_config_read(const char *config_filename) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_config_read_pre ) {
+		void (*preHookFunc) (const char *config_filename);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_config_read_pre[hIndex].func;
+			preHookFunc(config_filename);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.config_read(config_filename);
+	}
+	if( HPMHooks.count.HP_atcommand_config_read_post ) {
+		void (*postHookFunc) (const char *config_filename);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_config_read_post[hIndex].func;
+			postHookFunc(config_filename);
+		}
+	}
+	return;
+}
+int HP_atcommand_stopattack(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_atcommand_stopattack_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_stopattack_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_atcommand_stopattack_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.atcommand.stopattack(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_atcommand_stopattack_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_stopattack_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_atcommand_stopattack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_atcommand_pvpoff_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_atcommand_pvpoff_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_pvpoff_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_atcommand_pvpoff_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.atcommand.pvpoff_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_atcommand_pvpoff_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_pvpoff_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_atcommand_pvpoff_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_atcommand_pvpon_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_atcommand_pvpon_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_pvpon_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_atcommand_pvpon_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.atcommand.pvpon_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_atcommand_pvpon_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_pvpon_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_atcommand_pvpon_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_atcommand_atkillmonster_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_atcommand_atkillmonster_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_atkillmonster_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_atcommand_atkillmonster_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.atcommand.atkillmonster_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_atcommand_atkillmonster_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_atkillmonster_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_atcommand_atkillmonster_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_atcommand_raise_sub(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_raise_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_raise_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_raise_sub_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.raise_sub(sd);
+	}
+	if( HPMHooks.count.HP_atcommand_raise_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_raise_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_raise_sub_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_atcommand_get_jail_time(int jailtime, int *year, int *month, int *day, int *hour, int *minute) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_get_jail_time_pre ) {
+		void (*preHookFunc) (int *jailtime, int *year, int *month, int *day, int *hour, int *minute);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_jail_time_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_get_jail_time_pre[hIndex].func;
+			preHookFunc(&jailtime, year, month, day, hour, minute);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.get_jail_time(jailtime, year, month, day, hour, minute);
+	}
+	if( HPMHooks.count.HP_atcommand_get_jail_time_post ) {
+		void (*postHookFunc) (int *jailtime, int *year, int *month, int *day, int *hour, int *minute);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_jail_time_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_get_jail_time_post[hIndex].func;
+			postHookFunc(&jailtime, year, month, day, hour, minute);
+		}
+	}
+	return;
+}
+int HP_atcommand_cleanfloor_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_atcommand_cleanfloor_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cleanfloor_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_atcommand_cleanfloor_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.atcommand.cleanfloor_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_atcommand_cleanfloor_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cleanfloor_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_atcommand_cleanfloor_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_atcommand_mutearea_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_atcommand_mutearea_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_mutearea_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_atcommand_mutearea_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.atcommand.mutearea_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_atcommand_mutearea_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_mutearea_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_atcommand_mutearea_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_atcommand_commands_sub(struct map_session_data *sd, const int fd, AtCommandType type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_commands_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const int *fd, AtCommandType *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_commands_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_commands_sub_pre[hIndex].func;
+			preHookFunc(sd, &fd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.commands_sub(sd, fd, type);
+	}
+	if( HPMHooks.count.HP_atcommand_commands_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const int *fd, AtCommandType *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_commands_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_commands_sub_post[hIndex].func;
+			postHookFunc(sd, &fd, &type);
+		}
+	}
+	return;
+}
+void HP_atcommand_cmd_db_clear(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_cmd_db_clear_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cmd_db_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_cmd_db_clear_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.cmd_db_clear();
+	}
+	if( HPMHooks.count.HP_atcommand_cmd_db_clear_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cmd_db_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_cmd_db_clear_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_atcommand_cmd_db_clear_sub(DBKey key, DBData *data, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_atcommand_cmd_db_clear_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cmd_db_clear_sub_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_atcommand_cmd_db_clear_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.atcommand.cmd_db_clear_sub(key, data, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_atcommand_cmd_db_clear_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cmd_db_clear_sub_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_atcommand_cmd_db_clear_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_atcommand_doload(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_doload_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_doload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_doload_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.doload();
+	}
+	if( HPMHooks.count.HP_atcommand_doload_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_doload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_doload_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_atcommand_base_commands(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_atcommand_base_commands_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_base_commands_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_atcommand_base_commands_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.atcommand.base_commands();
+	}
+	if( HPMHooks.count.HP_atcommand_base_commands_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_base_commands_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_atcommand_base_commands_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+/* battle */
+void HP_battle_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_battle_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.battle.init();
+	}
+	if( HPMHooks.count.HP_battle_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_battle_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_battle_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.battle.final();
+	}
+	if( HPMHooks.count.HP_battle_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct Damage HP_battle_calc_attack(int attack_type, struct block_list *bl, struct block_list *target, uint16 skill_id, uint16 skill_lv, int count) {
+	int hIndex = 0;
+	struct Damage retVal___;
+	memset(&retVal___, '\0', sizeof(struct Damage));
+	if( HPMHooks.count.HP_battle_calc_attack_pre ) {
+		struct Damage (*preHookFunc) (int *attack_type, struct block_list *bl, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_attack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_attack_pre[hIndex].func;
+			retVal___ = preHookFunc(&attack_type, bl, target, &skill_id, &skill_lv, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_attack(attack_type, bl, target, skill_id, skill_lv, count);
+	}
+	if( HPMHooks.count.HP_battle_calc_attack_post ) {
+		struct Damage (*postHookFunc) (struct Damage retVal___, int *attack_type, struct block_list *bl, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_attack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_attack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &attack_type, bl, target, &skill_id, &skill_lv, &count);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_damage(struct block_list *src, struct block_list *bl, struct Damage *d, int64 damage, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_damage_pre ) {
+		int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, struct Damage *d, int64 *damage, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, d, &damage, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_damage(src, bl, d, damage, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_battle_calc_damage_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, struct Damage *d, int64 *damage, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, d, &damage, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_gvg_damage(struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_gvg_damage_pre ) {
+		int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_gvg_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_gvg_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &damage, &div_, &skill_id, &skill_lv, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_gvg_damage(src, bl, damage, div_, skill_id, skill_lv, flag);
+	}
+	if( HPMHooks.count.HP_battle_calc_gvg_damage_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_gvg_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_gvg_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &damage, &div_, &skill_id, &skill_lv, &flag);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_bg_damage(struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_bg_damage_pre ) {
+		int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_bg_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_bg_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &damage, &div_, &skill_id, &skill_lv, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_bg_damage(src, bl, damage, div_, skill_id, skill_lv, flag);
+	}
+	if( HPMHooks.count.HP_battle_calc_bg_damage_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 *damage, int *div_, uint16 *skill_id, uint16 *skill_lv, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_bg_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_bg_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &damage, &div_, &skill_id, &skill_lv, &flag);
+		}
+	}
+	return retVal___;
+}
+enum damage_lv HP_battle_weapon_attack(struct block_list *bl, struct block_list *target, unsigned int tick, int flag) {
+	int hIndex = 0;
+	enum damage_lv retVal___;
+	memset(&retVal___, '\0', sizeof(enum damage_lv));
+	if( HPMHooks.count.HP_battle_weapon_attack_pre ) {
+		enum damage_lv (*preHookFunc) (struct block_list *bl, struct block_list *target, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_weapon_attack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_weapon_attack_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, target, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.weapon_attack(bl, target, tick, flag);
+	}
+	if( HPMHooks.count.HP_battle_weapon_attack_post ) {
+		enum damage_lv (*postHookFunc) (enum damage_lv retVal___, struct block_list *bl, struct block_list *target, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_weapon_attack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_weapon_attack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, target, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+struct Damage HP_battle_calc_weapon_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int wflag) {
+	int hIndex = 0;
+	struct Damage retVal___;
+	memset(&retVal___, '\0', sizeof(struct Damage));
+	if( HPMHooks.count.HP_battle_calc_weapon_attack_pre ) {
+		struct Damage (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *wflag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_attack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_weapon_attack_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &wflag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_weapon_attack(src, target, skill_id, skill_lv, wflag);
+	}
+	if( HPMHooks.count.HP_battle_calc_weapon_attack_post ) {
+		struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *wflag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_attack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_weapon_attack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &wflag);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_delay_damage(unsigned int tick, int amotion, struct block_list *src, struct block_list *target, int attack_type, uint16 skill_id, uint16 skill_lv, int64 damage, enum damage_lv dmg_lv, int ddelay, bool additional_effects) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_delay_damage_pre ) {
+		int (*preHookFunc) (unsigned int *tick, int *amotion, struct block_list *src, struct block_list *target, int *attack_type, uint16 *skill_id, uint16 *skill_lv, int64 *damage, enum damage_lv *dmg_lv, int *ddelay, bool *additional_effects);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_delay_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(&tick, &amotion, src, target, &attack_type, &skill_id, &skill_lv, &damage, &dmg_lv, &ddelay, &additional_effects);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.delay_damage(tick, amotion, src, target, attack_type, skill_id, skill_lv, damage, dmg_lv, ddelay, additional_effects);
+	}
+	if( HPMHooks.count.HP_battle_delay_damage_post ) {
+		int (*postHookFunc) (int retVal___, unsigned int *tick, int *amotion, struct block_list *src, struct block_list *target, int *attack_type, uint16 *skill_id, uint16 *skill_lv, int64 *damage, enum damage_lv *dmg_lv, int *ddelay, bool *additional_effects);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_delay_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tick, &amotion, src, target, &attack_type, &skill_id, &skill_lv, &damage, &dmg_lv, &ddelay, &additional_effects);
+		}
+	}
+	return retVal___;
+}
+void HP_battle_drain(struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_battle_drain_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct block_list *tbl, int64 *rdamage, int64 *ldamage, int *race, int *boss);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_drain_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_drain_pre[hIndex].func;
+			preHookFunc(sd, tbl, &rdamage, &ldamage, &race, &boss);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.battle.drain(sd, tbl, rdamage, ldamage, race, boss);
+	}
+	if( HPMHooks.count.HP_battle_drain_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct block_list *tbl, int64 *rdamage, int64 *ldamage, int *race, int *boss);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_drain_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_drain_post[hIndex].func;
+			postHookFunc(sd, tbl, &rdamage, &ldamage, &race, &boss);
+		}
+	}
+	return;
+}
+int64 HP_battle_calc_return_damage(struct block_list *bl, struct block_list *src, int64 *p1, int flag, uint16 skill_id, int *rdelay) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_return_damage_pre ) {
+		int64 (*preHookFunc) (struct block_list *bl, struct block_list *src, int64 *p1, int *flag, uint16 *skill_id, int *rdelay);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_return_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_return_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, src, p1, &flag, &skill_id, rdelay);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_return_damage(bl, src, p1, flag, skill_id, rdelay);
+	}
+	if( HPMHooks.count.HP_battle_calc_return_damage_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *bl, struct block_list *src, int64 *p1, int *flag, uint16 *skill_id, int *rdelay);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_return_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_return_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, src, p1, &flag, &skill_id, rdelay);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_attr_ratio(int atk_elem, int def_type, int def_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_attr_ratio_pre ) {
+		int (*preHookFunc) (int *atk_elem, int *def_type, int *def_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_ratio_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_attr_ratio_pre[hIndex].func;
+			retVal___ = preHookFunc(&atk_elem, &def_type, &def_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.attr_ratio(atk_elem, def_type, def_lv);
+	}
+	if( HPMHooks.count.HP_battle_attr_ratio_post ) {
+		int (*postHookFunc) (int retVal___, int *atk_elem, int *def_type, int *def_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_ratio_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_attr_ratio_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &atk_elem, &def_type, &def_lv);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_attr_fix(struct block_list *src, struct block_list *target, int64 damage, int atk_elem, int def_type, int def_lv) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_attr_fix_pre ) {
+		int64 (*preHookFunc) (struct block_list *src, struct block_list *target, int64 *damage, int *atk_elem, int *def_type, int *def_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_fix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_attr_fix_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &damage, &atk_elem, &def_type, &def_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.attr_fix(src, target, damage, atk_elem, def_type, def_lv);
+	}
+	if( HPMHooks.count.HP_battle_attr_fix_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, int64 *damage, int *atk_elem, int *def_type, int *def_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_fix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_attr_fix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &damage, &atk_elem, &def_type, &def_lv);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_cardfix(int attack_type, struct block_list *src, struct block_list *target, int nk, int s_ele, int s_ele_, int64 damage, int left, int flag) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_cardfix_pre ) {
+		int64 (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, int *nk, int *s_ele, int *s_ele_, int64 *damage, int *left, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_cardfix_pre[hIndex].func;
+			retVal___ = preHookFunc(&attack_type, src, target, &nk, &s_ele, &s_ele_, &damage, &left, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_cardfix(attack_type, src, target, nk, s_ele, s_ele_, damage, left, flag);
+	}
+	if( HPMHooks.count.HP_battle_calc_cardfix_post ) {
+		int64 (*postHookFunc) (int64 retVal___, int *attack_type, struct block_list *src, struct block_list *target, int *nk, int *s_ele, int *s_ele_, int64 *damage, int *left, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_cardfix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &attack_type, src, target, &nk, &s_ele, &s_ele_, &damage, &left, &flag);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_elefix(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int nk, int n_ele, int s_ele, int s_ele_, bool left, int flag) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_elefix_pre ) {
+		int64 (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *nk, int *n_ele, int *s_ele, int *s_ele_, bool *left, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_elefix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_elefix_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &damage, &nk, &n_ele, &s_ele, &s_ele_, &left, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_elefix(src, target, skill_id, skill_lv, damage, nk, n_ele, s_ele, s_ele_, left, flag);
+	}
+	if( HPMHooks.count.HP_battle_calc_elefix_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *nk, int *n_ele, int *s_ele, int *s_ele_, bool *left, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_elefix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_elefix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &damage, &nk, &n_ele, &s_ele, &s_ele_, &left, &flag);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_masteryfix(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int div, bool left, bool weapon) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_masteryfix_pre ) {
+		int64 (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &damage, &div, &left, &weapon);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_masteryfix(src, target, skill_id, skill_lv, damage, div, left, weapon);
+	}
+	if( HPMHooks.count.HP_battle_calc_masteryfix_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &damage, &div, &left, &weapon);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_calc_skillratio(int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int skillratio, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_calc_skillratio_pre ) {
+		int (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_skillratio_pre[hIndex].func;
+			retVal___ = preHookFunc(&attack_type, src, target, &skill_id, &skill_lv, &skillratio, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_skillratio(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
+	}
+	if( HPMHooks.count.HP_battle_calc_skillratio_post ) {
+		int (*postHookFunc) (int retVal___, int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_skillratio_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &attack_type, src, target, &skill_id, &skill_lv, &skillratio, &flag);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_sizefix(struct map_session_data *sd, int64 damage, int type, int size, bool ignore) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_sizefix_pre ) {
+		int64 (*preHookFunc) (struct map_session_data *sd, int64 *damage, int *type, int *size, bool *ignore);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_sizefix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_sizefix_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &damage, &type, &size, &ignore);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_sizefix(sd, damage, type, size, ignore);
+	}
+	if( HPMHooks.count.HP_battle_calc_sizefix_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct map_session_data *sd, int64 *damage, int *type, int *size, bool *ignore);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_sizefix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_sizefix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &damage, &type, &size, &ignore);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_weapon_damage(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, struct weapon_atk *watk, int nk, bool n_ele, short s_ele, short s_ele_, int size, int type, int flag, int flag2) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_weapon_damage_pre ) {
+		int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, struct weapon_atk *watk, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *size, int *type, int *flag, int *flag2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_weapon_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, watk, &nk, &n_ele, &s_ele, &s_ele_, &size, &type, &flag, &flag2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_weapon_damage(src, bl, skill_id, skill_lv, watk, nk, n_ele, s_ele, s_ele_, size, type, flag, flag2);
+	}
+	if( HPMHooks.count.HP_battle_calc_weapon_damage_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, struct weapon_atk *watk, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *size, int *type, int *flag, int *flag2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_weapon_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, watk, &nk, &n_ele, &s_ele, &s_ele_, &size, &type, &flag, &flag2);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_defense(int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int flag, int pdef) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_defense_pre ) {
+		int64 (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *flag, int *pdef);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_defense_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_defense_pre[hIndex].func;
+			retVal___ = preHookFunc(&attack_type, src, target, &skill_id, &skill_lv, &damage, &flag, &pdef);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_defense(attack_type, src, target, skill_id, skill_lv, damage, flag, pdef);
+	}
+	if( HPMHooks.count.HP_battle_calc_defense_post ) {
+		int64 (*postHookFunc) (int64 retVal___, int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *flag, int *pdef);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_defense_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_defense_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &attack_type, src, target, &skill_id, &skill_lv, &damage, &flag, &pdef);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_battle_get_master(struct block_list *src) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_battle_get_master_pre ) {
+		struct block_list* (*preHookFunc) (struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_master_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_get_master_pre[hIndex].func;
+			retVal___ = preHookFunc(src);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.get_master(src);
+	}
+	if( HPMHooks.count.HP_battle_get_master_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_master_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_get_master_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_battle_get_targeted(struct block_list *target) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_battle_get_targeted_pre ) {
+		struct block_list* (*preHookFunc) (struct block_list *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_targeted_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_get_targeted_pre[hIndex].func;
+			retVal___ = preHookFunc(target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.get_targeted(target);
+	}
+	if( HPMHooks.count.HP_battle_get_targeted_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_targeted_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_get_targeted_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, target);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_battle_get_enemy(struct block_list *target, int type, int range) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_battle_get_enemy_pre ) {
+		struct block_list* (*preHookFunc) (struct block_list *target, int *type, int *range);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_get_enemy_pre[hIndex].func;
+			retVal___ = preHookFunc(target, &type, &range);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.get_enemy(target, type, range);
+	}
+	if( HPMHooks.count.HP_battle_get_enemy_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *target, int *type, int *range);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_get_enemy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, target, &type, &range);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_get_target(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_get_target_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_target_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_get_target_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.get_target(bl);
+	}
+	if( HPMHooks.count.HP_battle_get_target_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_target_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_get_target_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_get_current_skill(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_get_current_skill_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_current_skill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_get_current_skill_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.get_current_skill(bl);
+	}
+	if( HPMHooks.count.HP_battle_get_current_skill_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_current_skill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_get_current_skill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_check_undead(int race, int element) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_check_undead_pre ) {
+		int (*preHookFunc) (int *race, int *element);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_undead_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_check_undead_pre[hIndex].func;
+			retVal___ = preHookFunc(&race, &element);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.check_undead(race, element);
+	}
+	if( HPMHooks.count.HP_battle_check_undead_post ) {
+		int (*postHookFunc) (int retVal___, int *race, int *element);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_undead_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_check_undead_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &race, &element);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_check_target(struct block_list *src, struct block_list *target, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_check_target_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_target_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_check_target_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.check_target(src, target, flag);
+	}
+	if( HPMHooks.count.HP_battle_check_target_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_target_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_check_target_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &flag);
+		}
+	}
+	return retVal___;
+}
+bool HP_battle_check_range(struct block_list *src, struct block_list *bl, int range) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_battle_check_range_pre ) {
+		bool (*preHookFunc) (struct block_list *src, struct block_list *bl, int *range);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_range_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_check_range_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &range);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.check_range(src, bl, range);
+	}
+	if( HPMHooks.count.HP_battle_check_range_post ) {
+		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, int *range);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_range_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_check_range_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &range);
+		}
+	}
+	return retVal___;
+}
+void HP_battle_consume_ammo(struct map_session_data *sd, int skill_id, int lv) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_battle_consume_ammo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *skill_id, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_consume_ammo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_consume_ammo_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.battle.consume_ammo(sd, skill_id, lv);
+	}
+	if( HPMHooks.count.HP_battle_consume_ammo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *skill_id, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_consume_ammo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_consume_ammo_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &lv);
+		}
+	}
+	return;
+}
+int HP_battle_get_targeted_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_get_targeted_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_targeted_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_battle_get_targeted_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.battle.get_targeted_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_battle_get_targeted_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_targeted_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_battle_get_targeted_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_get_enemy_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_get_enemy_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_battle_get_enemy_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.battle.get_enemy_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_battle_get_enemy_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_battle_get_enemy_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_get_enemy_area_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_get_enemy_area_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_battle_get_enemy_area_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.battle.get_enemy_area_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_battle_get_enemy_area_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_battle_get_enemy_area_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_delay_damage_sub(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_delay_damage_sub_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_delay_damage_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.delay_damage_sub(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_battle_delay_damage_sub_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_delay_damage_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_blewcount_bonus(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_blewcount_bonus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_blewcount_bonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_blewcount_bonus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.blewcount_bonus(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_battle_blewcount_bonus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_blewcount_bonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_blewcount_bonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_range_type(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_range_type_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_range_type_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_range_type_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.range_type(src, target, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_battle_range_type_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_range_type_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_range_type_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_base_damage(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int nk, bool n_ele, short s_ele, short s_ele_, int type, int flag, int flag2) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_base_damage_pre ) {
+		int64 (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *type, int *flag, int *flag2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_base_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &nk, &n_ele, &s_ele, &s_ele_, &type, &flag, &flag2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_base_damage(src, bl, skill_id, skill_lv, nk, n_ele, s_ele, s_ele_, type, flag, flag2);
+	}
+	if( HPMHooks.count.HP_battle_calc_base_damage_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *nk, bool *n_ele, short *s_ele, short *s_ele_, int *type, int *flag, int *flag2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_base_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &nk, &n_ele, &s_ele, &s_ele_, &type, &flag, &flag2);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_calc_base_damage2(struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_calc_base_damage2_pre ) {
+		int64 (*preHookFunc) (struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short *t_size, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_base_damage2_pre[hIndex].func;
+			retVal___ = preHookFunc(st, wa, sc, &t_size, sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_base_damage2(st, wa, sc, t_size, sd, flag);
+	}
+	if( HPMHooks.count.HP_battle_calc_base_damage2_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short *t_size, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_base_damage2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st, wa, sc, &t_size, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+struct Damage HP_battle_calc_misc_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag) {
+	int hIndex = 0;
+	struct Damage retVal___;
+	memset(&retVal___, '\0', sizeof(struct Damage));
+	if( HPMHooks.count.HP_battle_calc_misc_attack_pre ) {
+		struct Damage (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &mflag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_misc_attack(src, target, skill_id, skill_lv, mflag);
+	}
+	if( HPMHooks.count.HP_battle_calc_misc_attack_post ) {
+		struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &mflag);
+		}
+	}
+	return retVal___;
+}
+struct Damage HP_battle_calc_magic_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag) {
+	int hIndex = 0;
+	struct Damage retVal___;
+	memset(&retVal___, '\0', sizeof(struct Damage));
+	if( HPMHooks.count.HP_battle_calc_magic_attack_pre ) {
+		struct Damage (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_magic_attack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_magic_attack_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &mflag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_magic_attack(src, target, skill_id, skill_lv, mflag);
+	}
+	if( HPMHooks.count.HP_battle_calc_magic_attack_post ) {
+		struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_magic_attack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_magic_attack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &mflag);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_adjust_skill_damage(int m, unsigned short skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_adjust_skill_damage_pre ) {
+		int (*preHookFunc) (int *m, unsigned short *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_adjust_skill_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_adjust_skill_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.adjust_skill_damage(m, skill_id);
+	}
+	if( HPMHooks.count.HP_battle_adjust_skill_damage_post ) {
+		int (*postHookFunc) (int retVal___, int *m, unsigned short *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_adjust_skill_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_adjust_skill_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int64 HP_battle_add_mastery(struct map_session_data *sd, struct block_list *target, int64 dmg, int type) {
+	int hIndex = 0;
+	int64 retVal___;
+	memset(&retVal___, '\0', sizeof(int64));
+	if( HPMHooks.count.HP_battle_add_mastery_pre ) {
+		int64 (*preHookFunc) (struct map_session_data *sd, struct block_list *target, int64 *dmg, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_add_mastery_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_add_mastery_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, target, &dmg, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.add_mastery(sd, target, dmg, type);
+	}
+	if( HPMHooks.count.HP_battle_add_mastery_post ) {
+		int64 (*postHookFunc) (int64 retVal___, struct map_session_data *sd, struct block_list *target, int64 *dmg, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_add_mastery_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_add_mastery_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, target, &dmg, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_calc_drain(int64 damage, int rate, int per) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_calc_drain_pre ) {
+		int (*preHookFunc) (int64 *damage, int *rate, int *per);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_drain_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_calc_drain_pre[hIndex].func;
+			retVal___ = preHookFunc(&damage, &rate, &per);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.calc_drain(damage, rate, per);
+	}
+	if( HPMHooks.count.HP_battle_calc_drain_post ) {
+		int (*postHookFunc) (int retVal___, int64 *damage, int *rate, int *per);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_drain_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_calc_drain_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &damage, &rate, &per);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_config_read(const char *cfgName) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_config_read_pre ) {
+		int (*preHookFunc) (const char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_config_read_pre[hIndex].func;
+			retVal___ = preHookFunc(cfgName);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.config_read(cfgName);
+	}
+	if( HPMHooks.count.HP_battle_config_read_post ) {
+		int (*postHookFunc) (int retVal___, const char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_config_read_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cfgName);
+		}
+	}
+	return retVal___;
+}
+void HP_battle_config_set_defaults(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_battle_config_set_defaults_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_set_defaults_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_config_set_defaults_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.battle.config_set_defaults();
+	}
+	if( HPMHooks.count.HP_battle_config_set_defaults_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_set_defaults_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_config_set_defaults_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_battle_config_set_value(const char *w1, const char *w2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_config_set_value_pre ) {
+		int (*preHookFunc) (const char *w1, const char *w2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_set_value_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_config_set_value_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.config_set_value(w1, w2);
+	}
+	if( HPMHooks.count.HP_battle_config_set_value_post ) {
+		int (*postHookFunc) (int retVal___, const char *w1, const char *w2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_set_value_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_config_set_value_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_config_get_value(const char *w1) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_config_get_value_pre ) {
+		int (*preHookFunc) (const char *w1);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_get_value_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_config_get_value_pre[hIndex].func;
+			retVal___ = preHookFunc(w1);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.config_get_value(w1);
+	}
+	if( HPMHooks.count.HP_battle_config_get_value_post ) {
+		int (*postHookFunc) (int retVal___, const char *w1);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_get_value_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_config_get_value_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1);
+		}
+	}
+	return retVal___;
+}
+void HP_battle_config_adjust(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_battle_config_adjust_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_adjust_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_config_adjust_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.battle.config_adjust();
+	}
+	if( HPMHooks.count.HP_battle_config_adjust_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_adjust_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_config_adjust_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct block_list* HP_battle_get_enemy_area(struct block_list *src, int x, int y, int range, int type, int ignore_id) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_battle_get_enemy_area_pre ) {
+		struct block_list* (*preHookFunc) (struct block_list *src, int *x, int *y, int *range, int *type, int *ignore_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_battle_get_enemy_area_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &x, &y, &range, &type, &ignore_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.battle.get_enemy_area(src, x, y, range, type, ignore_id);
+	}
+	if( HPMHooks.count.HP_battle_get_enemy_area_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *src, int *x, int *y, int *range, int *type, int *ignore_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_battle_get_enemy_area_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &x, &y, &range, &type, &ignore_id);
+		}
+	}
+	return retVal___;
+}
+int HP_battle_damage_area(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_battle_damage_area_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_damage_area_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_battle_damage_area_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.battle.damage_area(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_battle_damage_area_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_damage_area_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_battle_damage_area_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+/* bg */
+void HP_bg_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.init();
+	}
+	if( HPMHooks.count.HP_bg_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_bg_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.final();
+	}
+	if( HPMHooks.count.HP_bg_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct bg_arena* HP_bg_name2arena(char *name) {
+	int hIndex = 0;
+	struct bg_arena* retVal___ = NULL;
+	if( HPMHooks.count.HP_bg_name2arena_pre ) {
+		struct bg_arena* (*preHookFunc) (char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_name2arena_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_name2arena_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.name2arena(name);
+	}
+	if( HPMHooks.count.HP_bg_name2arena_post ) {
+		struct bg_arena* (*postHookFunc) (struct bg_arena* retVal___, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_name2arena_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_name2arena_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+void HP_bg_queue_add(struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_queue_add_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_queue_add_pre[hIndex].func;
+			preHookFunc(sd, arena, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.queue_add(sd, arena, type);
+	}
+	if( HPMHooks.count.HP_bg_queue_add_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_queue_add_post[hIndex].func;
+			postHookFunc(sd, arena, &type);
+		}
+	}
+	return;
+}
+enum BATTLEGROUNDS_QUEUE_ACK HP_bg_can_queue(struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type) {
+	int hIndex = 0;
+	enum BATTLEGROUNDS_QUEUE_ACK retVal___;
+	memset(&retVal___, '\0', sizeof(enum BATTLEGROUNDS_QUEUE_ACK));
+	if( HPMHooks.count.HP_bg_can_queue_pre ) {
+		enum BATTLEGROUNDS_QUEUE_ACK (*preHookFunc) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_can_queue_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_can_queue_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, arena, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.can_queue(sd, arena, type);
+	}
+	if( HPMHooks.count.HP_bg_can_queue_post ) {
+		enum BATTLEGROUNDS_QUEUE_ACK (*postHookFunc) (enum BATTLEGROUNDS_QUEUE_ACK retVal___, struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_can_queue_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_can_queue_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, arena, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_id2pos(int queue_id, int account_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_id2pos_pre ) {
+		int (*preHookFunc) (int *queue_id, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_id2pos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_id2pos_pre[hIndex].func;
+			retVal___ = preHookFunc(&queue_id, &account_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.id2pos(queue_id, account_id);
+	}
+	if( HPMHooks.count.HP_bg_id2pos_post ) {
+		int (*postHookFunc) (int retVal___, int *queue_id, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_id2pos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_id2pos_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &queue_id, &account_id);
+		}
+	}
+	return retVal___;
+}
+void HP_bg_queue_pc_cleanup(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_queue_pc_cleanup_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pc_cleanup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_queue_pc_cleanup_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.queue_pc_cleanup(sd);
+	}
+	if( HPMHooks.count.HP_bg_queue_pc_cleanup_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pc_cleanup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_queue_pc_cleanup_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_bg_begin(struct bg_arena *arena) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_begin_pre ) {
+		void (*preHookFunc) (struct bg_arena *arena);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_begin_pre[hIndex].func;
+			preHookFunc(arena);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.begin(arena);
+	}
+	if( HPMHooks.count.HP_bg_begin_post ) {
+		void (*postHookFunc) (struct bg_arena *arena);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_begin_post[hIndex].func;
+			postHookFunc(arena);
+		}
+	}
+	return;
+}
+int HP_bg_begin_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_begin_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_begin_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.begin_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_bg_begin_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_begin_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_bg_queue_pregame(struct bg_arena *arena) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_queue_pregame_pre ) {
+		void (*preHookFunc) (struct bg_arena *arena);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pregame_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_queue_pregame_pre[hIndex].func;
+			preHookFunc(arena);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.queue_pregame(arena);
+	}
+	if( HPMHooks.count.HP_bg_queue_pregame_post ) {
+		void (*postHookFunc) (struct bg_arena *arena);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pregame_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_queue_pregame_post[hIndex].func;
+			postHookFunc(arena);
+		}
+	}
+	return;
+}
+int HP_bg_fillup_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_fillup_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_fillup_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_fillup_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.fillup_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_bg_fillup_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_fillup_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_fillup_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_bg_queue_ready_ack(struct bg_arena *arena, struct map_session_data *sd, bool response) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_queue_ready_ack_pre ) {
+		void (*preHookFunc) (struct bg_arena *arena, struct map_session_data *sd, bool *response);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_ready_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_queue_ready_ack_pre[hIndex].func;
+			preHookFunc(arena, sd, &response);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.queue_ready_ack(arena, sd, response);
+	}
+	if( HPMHooks.count.HP_bg_queue_ready_ack_post ) {
+		void (*postHookFunc) (struct bg_arena *arena, struct map_session_data *sd, bool *response);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_ready_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_queue_ready_ack_post[hIndex].func;
+			postHookFunc(arena, sd, &response);
+		}
+	}
+	return;
+}
+void HP_bg_match_over(struct bg_arena *arena, bool canceled) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_match_over_pre ) {
+		void (*preHookFunc) (struct bg_arena *arena, bool *canceled);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_match_over_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_match_over_pre[hIndex].func;
+			preHookFunc(arena, &canceled);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.match_over(arena, canceled);
+	}
+	if( HPMHooks.count.HP_bg_match_over_post ) {
+		void (*postHookFunc) (struct bg_arena *arena, bool *canceled);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_match_over_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_match_over_post[hIndex].func;
+			postHookFunc(arena, &canceled);
+		}
+	}
+	return;
+}
+void HP_bg_queue_check(struct bg_arena *arena) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_queue_check_pre ) {
+		void (*preHookFunc) (struct bg_arena *arena);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_queue_check_pre[hIndex].func;
+			preHookFunc(arena);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.queue_check(arena);
+	}
+	if( HPMHooks.count.HP_bg_queue_check_post ) {
+		void (*postHookFunc) (struct bg_arena *arena);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_queue_check_post[hIndex].func;
+			postHookFunc(arena);
+		}
+	}
+	return;
+}
+struct battleground_data* HP_bg_team_search(int bg_id) {
+	int hIndex = 0;
+	struct battleground_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_bg_team_search_pre ) {
+		struct battleground_data* (*preHookFunc) (int *bg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_team_search_pre[hIndex].func;
+			retVal___ = preHookFunc(&bg_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.team_search(bg_id);
+	}
+	if( HPMHooks.count.HP_bg_team_search_post ) {
+		struct battleground_data* (*postHookFunc) (struct battleground_data* retVal___, int *bg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_team_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &bg_id);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_bg_getavailablesd(struct battleground_data *bgd) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_bg_getavailablesd_pre ) {
+		struct map_session_data* (*preHookFunc) (struct battleground_data *bgd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_getavailablesd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_getavailablesd_pre[hIndex].func;
+			retVal___ = preHookFunc(bgd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.getavailablesd(bgd);
+	}
+	if( HPMHooks.count.HP_bg_getavailablesd_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct battleground_data *bgd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_getavailablesd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_getavailablesd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bgd);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_team_delete(int bg_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_team_delete_pre ) {
+		int (*preHookFunc) (int *bg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_team_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(&bg_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.team_delete(bg_id);
+	}
+	if( HPMHooks.count.HP_bg_team_delete_post ) {
+		int (*postHookFunc) (int retVal___, int *bg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_team_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &bg_id);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_team_warp(int bg_id, unsigned short mapindex, short x, short y) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_team_warp_pre ) {
+		int (*preHookFunc) (int *bg_id, unsigned short *mapindex, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_warp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_team_warp_pre[hIndex].func;
+			retVal___ = preHookFunc(&bg_id, &mapindex, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.team_warp(bg_id, mapindex, x, y);
+	}
+	if( HPMHooks.count.HP_bg_team_warp_post ) {
+		int (*postHookFunc) (int retVal___, int *bg_id, unsigned short *mapindex, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_warp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_team_warp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &bg_id, &mapindex, &x, &y);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_send_dot_remove(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_send_dot_remove_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_dot_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_send_dot_remove_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.send_dot_remove(sd);
+	}
+	if( HPMHooks.count.HP_bg_send_dot_remove_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_dot_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_send_dot_remove_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_team_join(int bg_id, struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_team_join_pre ) {
+		int (*preHookFunc) (int *bg_id, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_join_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_team_join_pre[hIndex].func;
+			retVal___ = preHookFunc(&bg_id, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.team_join(bg_id, sd);
+	}
+	if( HPMHooks.count.HP_bg_team_join_post ) {
+		int (*postHookFunc) (int retVal___, int *bg_id, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_join_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_team_join_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &bg_id, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_team_leave(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_team_leave_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_team_leave_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.team_leave(sd, flag);
+	}
+	if( HPMHooks.count.HP_bg_team_leave_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_team_leave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_member_respawn(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_member_respawn_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_member_respawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_member_respawn_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.member_respawn(sd);
+	}
+	if( HPMHooks.count.HP_bg_member_respawn_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_member_respawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_member_respawn_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_create(unsigned short mapindex, short rx, short ry, const char *ev, const char *dev) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_create_pre ) {
+		int (*preHookFunc) (unsigned short *mapindex, short *rx, short *ry, const char *ev, const char *dev);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_create_pre[hIndex].func;
+			retVal___ = preHookFunc(&mapindex, &rx, &ry, ev, dev);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.create(mapindex, rx, ry, ev, dev);
+	}
+	if( HPMHooks.count.HP_bg_create_post ) {
+		int (*postHookFunc) (int retVal___, unsigned short *mapindex, short *rx, short *ry, const char *ev, const char *dev);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &mapindex, &rx, &ry, ev, dev);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_team_get_id(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_team_get_id_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_get_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_team_get_id_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.team_get_id(bl);
+	}
+	if( HPMHooks.count.HP_bg_team_get_id_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_get_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_team_get_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_send_message(struct map_session_data *sd, const char *mes, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_send_message_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_send_message_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.send_message(sd, mes, len);
+	}
+	if( HPMHooks.count.HP_bg_send_message_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_send_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, mes, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_send_xy_timer_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_send_xy_timer_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_bg_send_xy_timer_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.bg.send_xy_timer_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_bg_send_xy_timer_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_bg_send_xy_timer_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_bg_send_xy_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_bg_send_xy_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_send_xy_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.bg.send_xy_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_bg_send_xy_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_send_xy_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_bg_config_read(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_bg_config_read_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_bg_config_read_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.bg.config_read();
+	}
+	if( HPMHooks.count.HP_bg_config_read_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_bg_config_read_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+/* buyingstore */
+bool HP_buyingstore_setup(struct map_session_data *sd, unsigned char slots) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_buyingstore_setup_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, unsigned char *slots);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_setup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_buyingstore_setup_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &slots);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.buyingstore.setup(sd, slots);
+	}
+	if( HPMHooks.count.HP_buyingstore_setup_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned char *slots);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_setup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_buyingstore_setup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &slots);
+		}
+	}
+	return retVal___;
+}
+void HP_buyingstore_create(struct map_session_data *sd, int zenylimit, unsigned char result, const char *storename, const uint8 *itemlist, unsigned int count) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_buyingstore_create_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *zenylimit, unsigned char *result, const char *storename, const uint8 *itemlist, unsigned int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_buyingstore_create_pre[hIndex].func;
+			preHookFunc(sd, &zenylimit, &result, storename, itemlist, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.buyingstore.create(sd, zenylimit, result, storename, itemlist, count);
+	}
+	if( HPMHooks.count.HP_buyingstore_create_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *zenylimit, unsigned char *result, const char *storename, const uint8 *itemlist, unsigned int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_buyingstore_create_post[hIndex].func;
+			postHookFunc(sd, &zenylimit, &result, storename, itemlist, &count);
+		}
+	}
+	return;
+}
+void HP_buyingstore_close(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_buyingstore_close_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_buyingstore_close_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.buyingstore.close(sd);
+	}
+	if( HPMHooks.count.HP_buyingstore_close_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_buyingstore_close_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_buyingstore_open(struct map_session_data *sd, int account_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_buyingstore_open_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_open_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_buyingstore_open_pre[hIndex].func;
+			preHookFunc(sd, &account_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.buyingstore.open(sd, account_id);
+	}
+	if( HPMHooks.count.HP_buyingstore_open_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_open_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_buyingstore_open_post[hIndex].func;
+			postHookFunc(sd, &account_id);
+		}
+	}
+	return;
+}
+void HP_buyingstore_trade(struct map_session_data *sd, int account_id, unsigned int buyer_id, const uint8 *itemlist, unsigned int count) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_buyingstore_trade_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *account_id, unsigned int *buyer_id, const uint8 *itemlist, unsigned int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_trade_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_buyingstore_trade_pre[hIndex].func;
+			preHookFunc(sd, &account_id, &buyer_id, itemlist, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.buyingstore.trade(sd, account_id, buyer_id, itemlist, count);
+	}
+	if( HPMHooks.count.HP_buyingstore_trade_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *account_id, unsigned int *buyer_id, const uint8 *itemlist, unsigned int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_trade_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_buyingstore_trade_post[hIndex].func;
+			postHookFunc(sd, &account_id, &buyer_id, itemlist, &count);
+		}
+	}
+	return;
+}
+bool HP_buyingstore_search(struct map_session_data *sd, unsigned short nameid) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_buyingstore_search_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_buyingstore_search_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.buyingstore.search(sd, nameid);
+	}
+	if( HPMHooks.count.HP_buyingstore_search_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned short *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_buyingstore_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid);
+		}
+	}
+	return retVal___;
+}
+bool HP_buyingstore_searchall(struct map_session_data *sd, const struct s_search_store_search *s) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_buyingstore_searchall_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, const struct s_search_store_search *s);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_searchall_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_buyingstore_searchall_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, s);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.buyingstore.searchall(sd, s);
+	}
+	if( HPMHooks.count.HP_buyingstore_searchall_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const struct s_search_store_search *s);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_searchall_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_buyingstore_searchall_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, s);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_buyingstore_getuid(void) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_buyingstore_getuid_pre ) {
+		unsigned int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_getuid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_buyingstore_getuid_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.buyingstore.getuid();
+	}
+	if( HPMHooks.count.HP_buyingstore_getuid_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_getuid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_buyingstore_getuid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+/* chat */
+int HP_chat_create_pc_chat(struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_create_pc_chat_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_pc_chat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_create_pc_chat_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, title, pass, &limit, &pub);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.create_pc_chat(sd, title, pass, limit, pub);
+	}
+	if( HPMHooks.count.HP_chat_create_pc_chat_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_pc_chat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_create_pc_chat_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, title, pass, &limit, &pub);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_join(struct map_session_data *sd, int chatid, const char *pass) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_join_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *chatid, const char *pass);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_join_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_join_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &chatid, pass);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.join(sd, chatid, pass);
+	}
+	if( HPMHooks.count.HP_chat_join_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *chatid, const char *pass);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_join_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_join_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &chatid, pass);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_leave(struct map_session_data *sd, bool kicked) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_leave_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, bool *kicked);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_leave_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &kicked);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.leave(sd, kicked);
+	}
+	if( HPMHooks.count.HP_chat_leave_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool *kicked);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_leave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &kicked);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_change_owner(struct map_session_data *sd, const char *nextownername) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_change_owner_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *nextownername);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_owner_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_change_owner_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, nextownername);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.change_owner(sd, nextownername);
+	}
+	if( HPMHooks.count.HP_chat_change_owner_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *nextownername);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_owner_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_change_owner_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, nextownername);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_change_status(struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_change_status_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_status_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_change_status_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, title, pass, &limit, &pub);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.change_status(sd, title, pass, limit, pub);
+	}
+	if( HPMHooks.count.HP_chat_change_status_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_status_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_change_status_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, title, pass, &limit, &pub);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_kick(struct map_session_data *sd, const char *kickusername) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_kick_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *kickusername);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_kick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_kick_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, kickusername);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.kick(sd, kickusername);
+	}
+	if( HPMHooks.count.HP_chat_kick_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *kickusername);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_kick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_kick_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, kickusername);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_create_npc_chat(struct npc_data *nd, const char *title, int limit, bool pub, int trigger, const char *ev, int zeny, int minLvl, int maxLvl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_create_npc_chat_pre ) {
+		int (*preHookFunc) (struct npc_data *nd, const char *title, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_npc_chat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_create_npc_chat_pre[hIndex].func;
+			retVal___ = preHookFunc(nd, title, &limit, &pub, &trigger, ev, &zeny, &minLvl, &maxLvl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.create_npc_chat(nd, title, limit, pub, trigger, ev, zeny, minLvl, maxLvl);
+	}
+	if( HPMHooks.count.HP_chat_create_npc_chat_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd, const char *title, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_npc_chat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_create_npc_chat_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd, title, &limit, &pub, &trigger, ev, &zeny, &minLvl, &maxLvl);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_delete_npc_chat(struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_delete_npc_chat_pre ) {
+		int (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_delete_npc_chat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_delete_npc_chat_pre[hIndex].func;
+			retVal___ = preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.delete_npc_chat(nd);
+	}
+	if( HPMHooks.count.HP_chat_delete_npc_chat_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_delete_npc_chat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_delete_npc_chat_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_enable_event(struct chat_data *cd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_enable_event_pre ) {
+		int (*preHookFunc) (struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_enable_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_enable_event_pre[hIndex].func;
+			retVal___ = preHookFunc(cd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.enable_event(cd);
+	}
+	if( HPMHooks.count.HP_chat_enable_event_post ) {
+		int (*postHookFunc) (int retVal___, struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_enable_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_enable_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cd);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_disable_event(struct chat_data *cd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_disable_event_pre ) {
+		int (*preHookFunc) (struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_disable_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_disable_event_pre[hIndex].func;
+			retVal___ = preHookFunc(cd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.disable_event(cd);
+	}
+	if( HPMHooks.count.HP_chat_disable_event_post ) {
+		int (*postHookFunc) (int retVal___, struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_disable_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_disable_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cd);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_npc_kick_all(struct chat_data *cd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_npc_kick_all_pre ) {
+		int (*preHookFunc) (struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_npc_kick_all_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_npc_kick_all_pre[hIndex].func;
+			retVal___ = preHookFunc(cd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.npc_kick_all(cd);
+	}
+	if( HPMHooks.count.HP_chat_npc_kick_all_post ) {
+		int (*postHookFunc) (int retVal___, struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_npc_kick_all_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_npc_kick_all_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cd);
+		}
+	}
+	return retVal___;
+}
+int HP_chat_trigger_event(struct chat_data *cd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chat_trigger_event_pre ) {
+		int (*preHookFunc) (struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_trigger_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_trigger_event_pre[hIndex].func;
+			retVal___ = preHookFunc(cd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.trigger_event(cd);
+	}
+	if( HPMHooks.count.HP_chat_trigger_event_post ) {
+		int (*postHookFunc) (int retVal___, struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_trigger_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_trigger_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cd);
+		}
+	}
+	return retVal___;
+}
+struct chat_data* HP_chat_create(struct block_list *bl, const char *title, const char *pass, int limit, bool pub, int trigger, const char *ev, int zeny, int minLvl, int maxLvl) {
+	int hIndex = 0;
+	struct chat_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_chat_create_pre ) {
+		struct chat_data* (*preHookFunc) (struct block_list *bl, const char *title, const char *pass, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chat_create_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, title, pass, &limit, &pub, &trigger, ev, &zeny, &minLvl, &maxLvl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chat.create(bl, title, pass, limit, pub, trigger, ev, zeny, minLvl, maxLvl);
+	}
+	if( HPMHooks.count.HP_chat_create_post ) {
+		struct chat_data* (*postHookFunc) (struct chat_data* retVal___, struct block_list *bl, const char *title, const char *pass, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chat_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, title, pass, &limit, &pub, &trigger, ev, &zeny, &minLvl, &maxLvl);
+		}
+	}
+	return retVal___;
+}
+/* chrif */
+int HP_chrif_final(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_final_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_final_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.final();
+	}
+	if( HPMHooks.count.HP_chrif_final_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.init();
+	}
+	if( HPMHooks.count.HP_chrif_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_setuserid(char *id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_setuserid_pre ) {
+		void (*preHookFunc) (char *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setuserid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_setuserid_pre[hIndex].func;
+			preHookFunc(id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.setuserid(id);
+	}
+	if( HPMHooks.count.HP_chrif_setuserid_post ) {
+		void (*postHookFunc) (char *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setuserid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_setuserid_post[hIndex].func;
+			postHookFunc(id);
+		}
+	}
+	return;
+}
+void HP_chrif_setpasswd(char *pwd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_setpasswd_pre ) {
+		void (*preHookFunc) (char *pwd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setpasswd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_setpasswd_pre[hIndex].func;
+			preHookFunc(pwd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.setpasswd(pwd);
+	}
+	if( HPMHooks.count.HP_chrif_setpasswd_post ) {
+		void (*postHookFunc) (char *pwd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setpasswd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_setpasswd_post[hIndex].func;
+			postHookFunc(pwd);
+		}
+	}
+	return;
+}
+void HP_chrif_checkdefaultlogin(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_checkdefaultlogin_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_checkdefaultlogin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_checkdefaultlogin_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.checkdefaultlogin();
+	}
+	if( HPMHooks.count.HP_chrif_checkdefaultlogin_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_checkdefaultlogin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_checkdefaultlogin_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_chrif_setip(const char *ip) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_setip_pre ) {
+		int (*preHookFunc) (const char *ip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_setip_pre[hIndex].func;
+			retVal___ = preHookFunc(ip);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.setip(ip);
+	}
+	if( HPMHooks.count.HP_chrif_setip_post ) {
+		int (*postHookFunc) (int retVal___, const char *ip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_setip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ip);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_setport(uint16 port) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_setport_pre ) {
+		void (*preHookFunc) (uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setport_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_setport_pre[hIndex].func;
+			preHookFunc(&port);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.setport(port);
+	}
+	if( HPMHooks.count.HP_chrif_setport_post ) {
+		void (*postHookFunc) (uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setport_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_setport_post[hIndex].func;
+			postHookFunc(&port);
+		}
+	}
+	return;
+}
+int HP_chrif_isconnected(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_isconnected_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_isconnected_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_isconnected_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.isconnected();
+	}
+	if( HPMHooks.count.HP_chrif_isconnected_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_isconnected_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_isconnected_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_check_shutdown(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_check_shutdown_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_check_shutdown_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_check_shutdown_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.check_shutdown();
+	}
+	if( HPMHooks.count.HP_chrif_check_shutdown_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_check_shutdown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_check_shutdown_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct auth_node* HP_chrif_search(int account_id) {
+	int hIndex = 0;
+	struct auth_node* retVal___ = NULL;
+	if( HPMHooks.count.HP_chrif_search_pre ) {
+		struct auth_node* (*preHookFunc) (int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_search_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.search(account_id);
+	}
+	if( HPMHooks.count.HP_chrif_search_post ) {
+		struct auth_node* (*postHookFunc) (struct auth_node* retVal___, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id);
+		}
+	}
+	return retVal___;
+}
+struct auth_node* HP_chrif_auth_check(int account_id, int char_id, enum sd_state state) {
+	int hIndex = 0;
+	struct auth_node* retVal___ = NULL;
+	if( HPMHooks.count.HP_chrif_auth_check_pre ) {
+		struct auth_node* (*preHookFunc) (int *account_id, int *char_id, enum sd_state *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_auth_check_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &char_id, &state);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.auth_check(account_id, char_id, state);
+	}
+	if( HPMHooks.count.HP_chrif_auth_check_post ) {
+		struct auth_node* (*postHookFunc) (struct auth_node* retVal___, int *account_id, int *char_id, enum sd_state *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_auth_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &char_id, &state);
+		}
+	}
+	return retVal___;
+}
+bool HP_chrif_auth_delete(int account_id, int char_id, enum sd_state state) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_chrif_auth_delete_pre ) {
+		bool (*preHookFunc) (int *account_id, int *char_id, enum sd_state *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_auth_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &char_id, &state);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.auth_delete(account_id, char_id, state);
+	}
+	if( HPMHooks.count.HP_chrif_auth_delete_post ) {
+		bool (*postHookFunc) (bool retVal___, int *account_id, int *char_id, enum sd_state *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_auth_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &char_id, &state);
+		}
+	}
+	return retVal___;
+}
+bool HP_chrif_auth_finished(struct map_session_data *sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_chrif_auth_finished_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_finished_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_auth_finished_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.auth_finished(sd);
+	}
+	if( HPMHooks.count.HP_chrif_auth_finished_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_finished_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_auth_finished_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_authreq(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_authreq_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authreq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_authreq_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.authreq(sd);
+	}
+	if( HPMHooks.count.HP_chrif_authreq_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authreq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_authreq_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_chrif_authok(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_authok_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_authok_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.authok(fd);
+	}
+	if( HPMHooks.count.HP_chrif_authok_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_authok_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+int HP_chrif_scdata_request(int account_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_scdata_request_pre ) {
+		int (*preHookFunc) (int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_scdata_request_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_scdata_request_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.scdata_request(account_id, char_id);
+	}
+	if( HPMHooks.count.HP_chrif_scdata_request_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_scdata_request_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_scdata_request_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_save(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_save_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_save_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.save(sd, flag);
+	}
+	if( HPMHooks.count.HP_chrif_save_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_save_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_charselectreq(struct map_session_data *sd, uint32 s_ip) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_charselectreq_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint32 *s_ip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_charselectreq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_charselectreq_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &s_ip);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.charselectreq(sd, s_ip);
+	}
+	if( HPMHooks.count.HP_chrif_charselectreq_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint32 *s_ip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_charselectreq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_charselectreq_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &s_ip);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_changemapserver(struct map_session_data *sd, uint32 ip, uint16 port) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_changemapserver_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserver_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_changemapserver_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &ip, &port);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.changemapserver(sd, ip, port);
+	}
+	if( HPMHooks.count.HP_chrif_changemapserver_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserver_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_changemapserver_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &ip, &port);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_searchcharid(int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_searchcharid_pre ) {
+		int (*preHookFunc) (int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_searchcharid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_searchcharid_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.searchcharid(char_id);
+	}
+	if( HPMHooks.count.HP_chrif_searchcharid_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_searchcharid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_searchcharid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_changeemail(int id, const char *actual_email, const char *new_email) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_changeemail_pre ) {
+		int (*preHookFunc) (int *id, const char *actual_email, const char *new_email);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changeemail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_changeemail_pre[hIndex].func;
+			retVal___ = preHookFunc(&id, actual_email, new_email);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.changeemail(id, actual_email, new_email);
+	}
+	if( HPMHooks.count.HP_chrif_changeemail_post ) {
+		int (*postHookFunc) (int retVal___, int *id, const char *actual_email, const char *new_email);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changeemail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_changeemail_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id, actual_email, new_email);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_char_ask_name(int acc, const char *character_name, unsigned short operation_type, int year, int month, int day, int hour, int minute, int second) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_char_ask_name_pre ) {
+		int (*preHookFunc) (int *acc, const char *character_name, unsigned short *operation_type, int *year, int *month, int *day, int *hour, int *minute, int *second);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_char_ask_name_pre[hIndex].func;
+			retVal___ = preHookFunc(&acc, character_name, &operation_type, &year, &month, &day, &hour, &minute, &second);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.char_ask_name(acc, character_name, operation_type, year, month, day, hour, minute, second);
+	}
+	if( HPMHooks.count.HP_chrif_char_ask_name_post ) {
+		int (*postHookFunc) (int retVal___, int *acc, const char *character_name, unsigned short *operation_type, int *year, int *month, int *day, int *hour, int *minute, int *second);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_char_ask_name_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &acc, character_name, &operation_type, &year, &month, &day, &hour, &minute, &second);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_updatefamelist(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_updatefamelist_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_updatefamelist_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.updatefamelist(sd);
+	}
+	if( HPMHooks.count.HP_chrif_updatefamelist_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_updatefamelist_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_buildfamelist(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_buildfamelist_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_buildfamelist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_buildfamelist_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.buildfamelist();
+	}
+	if( HPMHooks.count.HP_chrif_buildfamelist_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_buildfamelist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_buildfamelist_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_save_scdata(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_save_scdata_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_scdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_save_scdata_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.save_scdata(sd);
+	}
+	if( HPMHooks.count.HP_chrif_save_scdata_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_scdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_save_scdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_ragsrvinfo(int base_rate, int job_rate, int drop_rate) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_ragsrvinfo_pre ) {
+		int (*preHookFunc) (int *base_rate, int *job_rate, int *drop_rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_ragsrvinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_ragsrvinfo_pre[hIndex].func;
+			retVal___ = preHookFunc(&base_rate, &job_rate, &drop_rate);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.ragsrvinfo(base_rate, job_rate, drop_rate);
+	}
+	if( HPMHooks.count.HP_chrif_ragsrvinfo_post ) {
+		int (*postHookFunc) (int retVal___, int *base_rate, int *job_rate, int *drop_rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_ragsrvinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_ragsrvinfo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &base_rate, &job_rate, &drop_rate);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_char_offline(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_char_offline_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_offline_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_char_offline_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.char_offline(sd);
+	}
+	if( HPMHooks.count.HP_chrif_char_offline_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_offline_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_char_offline_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_char_offline_nsd(int account_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_char_offline_nsd_pre ) {
+		int (*preHookFunc) (int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_offline_nsd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_char_offline_nsd_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.char_offline_nsd(account_id, char_id);
+	}
+	if( HPMHooks.count.HP_chrif_char_offline_nsd_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_offline_nsd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_char_offline_nsd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_char_reset_offline(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_char_reset_offline_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_reset_offline_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_char_reset_offline_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.char_reset_offline();
+	}
+	if( HPMHooks.count.HP_chrif_char_reset_offline_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_reset_offline_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_char_reset_offline_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_send_users_tochar(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_send_users_tochar_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_users_tochar_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_send_users_tochar_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.send_users_tochar();
+	}
+	if( HPMHooks.count.HP_chrif_send_users_tochar_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_users_tochar_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_send_users_tochar_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_char_online(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_char_online_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_online_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_char_online_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.char_online(sd);
+	}
+	if( HPMHooks.count.HP_chrif_char_online_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_online_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_char_online_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_changesex(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_changesex_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changesex_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_changesex_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.changesex(sd);
+	}
+	if( HPMHooks.count.HP_chrif_changesex_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changesex_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_changesex_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_divorce(int partner_id1, int partner_id2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_divorce_pre ) {
+		int (*preHookFunc) (int *partner_id1, int *partner_id2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_divorce_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_divorce_pre[hIndex].func;
+			retVal___ = preHookFunc(&partner_id1, &partner_id2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.divorce(partner_id1, partner_id2);
+	}
+	if( HPMHooks.count.HP_chrif_divorce_post ) {
+		int (*postHookFunc) (int retVal___, int *partner_id1, int *partner_id2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_divorce_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_divorce_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &partner_id1, &partner_id2);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_removefriend(int char_id, int friend_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_removefriend_pre ) {
+		int (*preHookFunc) (int *char_id, int *friend_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removefriend_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_removefriend_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &friend_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.removefriend(char_id, friend_id);
+	}
+	if( HPMHooks.count.HP_chrif_removefriend_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, int *friend_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removefriend_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_removefriend_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &friend_id);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_send_report(char *buf, int len) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_send_report_pre ) {
+		void (*preHookFunc) (char *buf, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_report_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_send_report_pre[hIndex].func;
+			preHookFunc(buf, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.send_report(buf, len);
+	}
+	if( HPMHooks.count.HP_chrif_send_report_post ) {
+		void (*postHookFunc) (char *buf, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_report_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_send_report_post[hIndex].func;
+			postHookFunc(buf, &len);
+		}
+	}
+	return;
+}
+int HP_chrif_flush_fifo(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_flush_fifo_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_flush_fifo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_flush_fifo_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.flush_fifo();
+	}
+	if( HPMHooks.count.HP_chrif_flush_fifo_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_flush_fifo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_flush_fifo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_skillid2idx(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_skillid2idx_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_skillid2idx_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_skillid2idx_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.skillid2idx(fd);
+	}
+	if( HPMHooks.count.HP_chrif_skillid2idx_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_skillid2idx_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_skillid2idx_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+bool HP_chrif_sd_to_auth(TBL_PC *sd, enum sd_state state) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_chrif_sd_to_auth_pre ) {
+		bool (*preHookFunc) (TBL_PC *sd, enum sd_state *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sd_to_auth_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_sd_to_auth_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &state);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.sd_to_auth(sd, state);
+	}
+	if( HPMHooks.count.HP_chrif_sd_to_auth_post ) {
+		bool (*postHookFunc) (bool retVal___, TBL_PC *sd, enum sd_state *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sd_to_auth_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_sd_to_auth_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &state);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_check_connect_char_server(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_check_connect_char_server_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_check_connect_char_server_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_check_connect_char_server_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.check_connect_char_server(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_chrif_check_connect_char_server_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_check_connect_char_server_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_check_connect_char_server_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+bool HP_chrif_auth_logout(TBL_PC *sd, enum sd_state state) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_chrif_auth_logout_pre ) {
+		bool (*preHookFunc) (TBL_PC *sd, enum sd_state *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_logout_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_auth_logout_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &state);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.auth_logout(sd, state);
+	}
+	if( HPMHooks.count.HP_chrif_auth_logout_post ) {
+		bool (*postHookFunc) (bool retVal___, TBL_PC *sd, enum sd_state *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_logout_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_auth_logout_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &state);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_save_ack(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_save_ack_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_save_ack_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.save_ack(fd);
+	}
+	if( HPMHooks.count.HP_chrif_save_ack_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_save_ack_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+int HP_chrif_reconnect(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_reconnect_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_reconnect_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_chrif_reconnect_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.chrif.reconnect(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_chrif_reconnect_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_reconnect_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_chrif_reconnect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_auth_db_cleanup_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_auth_db_cleanup_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.chrif.auth_db_cleanup_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_chrif_auth_db_cleanup_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_char_ask_name_answer(int acc, const char *player_name, uint16 type, uint16 answer) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_char_ask_name_answer_pre ) {
+		void (*preHookFunc) (int *acc, const char *player_name, uint16 *type, uint16 *answer);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_answer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_char_ask_name_answer_pre[hIndex].func;
+			preHookFunc(&acc, player_name, &type, &answer);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.char_ask_name_answer(acc, player_name, type, answer);
+	}
+	if( HPMHooks.count.HP_chrif_char_ask_name_answer_post ) {
+		void (*postHookFunc) (int *acc, const char *player_name, uint16 *type, uint16 *answer);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_answer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_char_ask_name_answer_post[hIndex].func;
+			postHookFunc(&acc, player_name, &type, &answer);
+		}
+	}
+	return;
+}
+int HP_chrif_auth_db_final(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_auth_db_final_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_final_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_chrif_auth_db_final_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.chrif.auth_db_final(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_chrif_auth_db_final_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_final_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_chrif_auth_db_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_send_usercount_tochar(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_send_usercount_tochar_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_usercount_tochar_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_send_usercount_tochar_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.send_usercount_tochar(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_chrif_send_usercount_tochar_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_usercount_tochar_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_send_usercount_tochar_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_auth_db_cleanup(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_auth_db_cleanup_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.auth_db_cleanup(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_chrif_auth_db_cleanup_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_connect(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_connect_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_connect_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.connect(fd);
+	}
+	if( HPMHooks.count.HP_chrif_connect_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_connect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_connectack(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_connectack_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connectack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_connectack_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.connectack(fd);
+	}
+	if( HPMHooks.count.HP_chrif_connectack_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connectack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_connectack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_sendmap(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_sendmap_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_sendmap_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.sendmap(fd);
+	}
+	if( HPMHooks.count.HP_chrif_sendmap_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_sendmap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_sendmapack(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_sendmapack_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmapack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_sendmapack_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.sendmapack(fd);
+	}
+	if( HPMHooks.count.HP_chrif_sendmapack_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmapack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_sendmapack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_recvmap(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_recvmap_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvmap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_recvmap_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.recvmap(fd);
+	}
+	if( HPMHooks.count.HP_chrif_recvmap_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvmap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_recvmap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_changemapserverack(int account_id, int login_id1, int login_id2, int char_id, short map_index, short x, short y, uint32 ip, uint16 port) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_changemapserverack_pre ) {
+		int (*preHookFunc) (int *account_id, int *login_id1, int *login_id2, int *char_id, short *map_index, short *x, short *y, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserverack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_changemapserverack_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &login_id1, &login_id2, &char_id, &map_index, &x, &y, &ip, &port);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.changemapserverack(account_id, login_id1, login_id2, char_id, map_index, x, y, ip, port);
+	}
+	if( HPMHooks.count.HP_chrif_changemapserverack_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *login_id1, int *login_id2, int *char_id, short *map_index, short *x, short *y, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserverack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_changemapserverack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &login_id1, &login_id2, &char_id, &map_index, &x, &y, &ip, &port);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_changedsex(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_changedsex_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changedsex_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_changedsex_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.changedsex(fd);
+	}
+	if( HPMHooks.count.HP_chrif_changedsex_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changedsex_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_changedsex_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_divorceack(int char_id, int partner_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_divorceack_pre ) {
+		int (*preHookFunc) (int *char_id, int *partner_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_divorceack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_divorceack_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &partner_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.divorceack(char_id, partner_id);
+	}
+	if( HPMHooks.count.HP_chrif_divorceack_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, int *partner_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_divorceack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_divorceack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &partner_id);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_accountban(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_accountban_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_accountban_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_accountban_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.accountban(fd);
+	}
+	if( HPMHooks.count.HP_chrif_accountban_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_accountban_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_accountban_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_recvfamelist(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_recvfamelist_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvfamelist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_recvfamelist_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.recvfamelist(fd);
+	}
+	if( HPMHooks.count.HP_chrif_recvfamelist_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvfamelist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_recvfamelist_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_load_scdata(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_load_scdata_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_load_scdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_load_scdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.load_scdata(fd);
+	}
+	if( HPMHooks.count.HP_chrif_load_scdata_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_load_scdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_load_scdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_update_ip(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_update_ip_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_update_ip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_update_ip_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.update_ip(fd);
+	}
+	if( HPMHooks.count.HP_chrif_update_ip_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_update_ip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_update_ip_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+int HP_chrif_disconnectplayer(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_disconnectplayer_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_disconnectplayer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_disconnectplayer_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.disconnectplayer(fd);
+	}
+	if( HPMHooks.count.HP_chrif_disconnectplayer_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_disconnectplayer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_disconnectplayer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_removemap(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_removemap_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removemap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_removemap_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.removemap(fd);
+	}
+	if( HPMHooks.count.HP_chrif_removemap_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removemap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_removemap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_chrif_updatefamelist_ack(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_updatefamelist_ack_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_updatefamelist_ack_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.updatefamelist_ack(fd);
+	}
+	if( HPMHooks.count.HP_chrif_updatefamelist_ack_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_updatefamelist_ack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_keepalive(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_keepalive_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_keepalive_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.keepalive(fd);
+	}
+	if( HPMHooks.count.HP_chrif_keepalive_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_keepalive_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_chrif_keepalive_ack(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_keepalive_ack_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_keepalive_ack_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.keepalive_ack(fd);
+	}
+	if( HPMHooks.count.HP_chrif_keepalive_ack_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_keepalive_ack_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+int HP_chrif_deadopt(int father_id, int mother_id, int child_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_deadopt_pre ) {
+		int (*preHookFunc) (int *father_id, int *mother_id, int *child_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_deadopt_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_deadopt_pre[hIndex].func;
+			retVal___ = preHookFunc(&father_id, &mother_id, &child_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.deadopt(father_id, mother_id, child_id);
+	}
+	if( HPMHooks.count.HP_chrif_deadopt_post ) {
+		int (*postHookFunc) (int retVal___, int *father_id, int *mother_id, int *child_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_deadopt_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_deadopt_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &father_id, &mother_id, &child_id);
+		}
+	}
+	return retVal___;
+}
+void HP_chrif_authfail(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_authfail_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authfail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_authfail_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.authfail(fd);
+	}
+	if( HPMHooks.count.HP_chrif_authfail_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authfail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_authfail_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_chrif_on_ready(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_on_ready_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_on_ready_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_on_ready_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.on_ready();
+	}
+	if( HPMHooks.count.HP_chrif_on_ready_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_on_ready_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_on_ready_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_chrif_on_disconnect(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_chrif_on_disconnect_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_on_disconnect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_on_disconnect_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.chrif.on_disconnect();
+	}
+	if( HPMHooks.count.HP_chrif_on_disconnect_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_on_disconnect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_on_disconnect_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_chrif_parse(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_chrif_parse_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_parse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_chrif_parse_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.chrif.parse(fd);
+	}
+	if( HPMHooks.count.HP_chrif_parse_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_parse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_chrif_parse_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+/* clif */
+int HP_clif_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.init();
+	}
+	if( HPMHooks.count.HP_clif_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.final();
+	}
+	if( HPMHooks.count.HP_clif_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_clif_setip(const char *ip) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_setip_pre ) {
+		int (*preHookFunc) (const char *ip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_setip_pre[hIndex].func;
+			retVal___ = preHookFunc(ip);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.setip(ip);
+	}
+	if( HPMHooks.count.HP_clif_setip_post ) {
+		int (*postHookFunc) (int retVal___, const char *ip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_setip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ip);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_setbindip(const char *ip) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_setbindip_pre ) {
+		void (*preHookFunc) (const char *ip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setbindip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_setbindip_pre[hIndex].func;
+			preHookFunc(ip);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.setbindip(ip);
+	}
+	if( HPMHooks.count.HP_clif_setbindip_post ) {
+		void (*postHookFunc) (const char *ip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setbindip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_setbindip_post[hIndex].func;
+			postHookFunc(ip);
+		}
+	}
+	return;
+}
+void HP_clif_setport(uint16 port) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_setport_pre ) {
+		void (*preHookFunc) (uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setport_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_setport_pre[hIndex].func;
+			preHookFunc(&port);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.setport(port);
+	}
+	if( HPMHooks.count.HP_clif_setport_post ) {
+		void (*postHookFunc) (uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setport_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_setport_post[hIndex].func;
+			postHookFunc(&port);
+		}
+	}
+	return;
+}
+uint32 HP_clif_refresh_ip(void) {
+	int hIndex = 0;
+	uint32 retVal___;
+	memset(&retVal___, '\0', sizeof(uint32));
+	if( HPMHooks.count.HP_clif_refresh_ip_pre ) {
+		uint32 (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_ip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_refresh_ip_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.refresh_ip();
+	}
+	if( HPMHooks.count.HP_clif_refresh_ip_post ) {
+		uint32 (*postHookFunc) (uint32 retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_ip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_refresh_ip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_send(const void *buf, int len, struct block_list *bl, enum send_target type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_send_pre ) {
+		int (*preHookFunc) (const void *buf, int *len, struct block_list *bl, enum send_target *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_send_pre[hIndex].func;
+			retVal___ = preHookFunc(buf, &len, bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.send(buf, len, bl, type);
+	}
+	if( HPMHooks.count.HP_clif_send_post ) {
+		int (*postHookFunc) (int retVal___, const void *buf, int *len, struct block_list *bl, enum send_target *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_send_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, buf, &len, bl, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_send_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_send_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_clif_send_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.clif.send_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_clif_send_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_clif_send_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_parse(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_parse_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_parse_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.parse(fd);
+	}
+	if( HPMHooks.count.HP_clif_parse_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_parse_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_clif_parse_cmd(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_clif_parse_cmd_pre ) {
+		unsigned short (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_cmd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_parse_cmd_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.parse_cmd(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_parse_cmd_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_cmd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_parse_cmd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd, sd);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_clif_decrypt_cmd(int cmd, struct map_session_data *sd) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_clif_decrypt_cmd_pre ) {
+		unsigned short (*preHookFunc) (int *cmd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_decrypt_cmd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_decrypt_cmd_pre[hIndex].func;
+			retVal___ = preHookFunc(&cmd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.decrypt_cmd(cmd, sd);
+	}
+	if( HPMHooks.count.HP_clif_decrypt_cmd_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, int *cmd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_decrypt_cmd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_decrypt_cmd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &cmd, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_authok(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_authok_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_authok_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.authok(sd);
+	}
+	if( HPMHooks.count.HP_clif_authok_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_authok_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_authrefuse(int fd, uint8 error_code) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_authrefuse_pre ) {
+		void (*preHookFunc) (int *fd, uint8 *error_code);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authrefuse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_authrefuse_pre[hIndex].func;
+			preHookFunc(&fd, &error_code);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.authrefuse(fd, error_code);
+	}
+	if( HPMHooks.count.HP_clif_authrefuse_post ) {
+		void (*postHookFunc) (int *fd, uint8 *error_code);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authrefuse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_authrefuse_post[hIndex].func;
+			postHookFunc(&fd, &error_code);
+		}
+	}
+	return;
+}
+void HP_clif_authfail_fd(int fd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_authfail_fd_pre ) {
+		void (*preHookFunc) (int *fd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authfail_fd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_authfail_fd_pre[hIndex].func;
+			preHookFunc(&fd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.authfail_fd(fd, type);
+	}
+	if( HPMHooks.count.HP_clif_authfail_fd_post ) {
+		void (*postHookFunc) (int *fd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authfail_fd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_authfail_fd_post[hIndex].func;
+			postHookFunc(&fd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_charselectok(int id, uint8 ok) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_charselectok_pre ) {
+		void (*preHookFunc) (int *id, uint8 *ok);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charselectok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_charselectok_pre[hIndex].func;
+			preHookFunc(&id, &ok);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.charselectok(id, ok);
+	}
+	if( HPMHooks.count.HP_clif_charselectok_post ) {
+		void (*postHookFunc) (int *id, uint8 *ok);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charselectok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_charselectok_post[hIndex].func;
+			postHookFunc(&id, &ok);
+		}
+	}
+	return;
+}
+void HP_clif_dropflooritem(struct flooritem_data *fitem) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_dropflooritem_pre ) {
+		void (*preHookFunc) (struct flooritem_data *fitem);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropflooritem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_dropflooritem_pre[hIndex].func;
+			preHookFunc(fitem);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.dropflooritem(fitem);
+	}
+	if( HPMHooks.count.HP_clif_dropflooritem_post ) {
+		void (*postHookFunc) (struct flooritem_data *fitem);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropflooritem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_dropflooritem_post[hIndex].func;
+			postHookFunc(fitem);
+		}
+	}
+	return;
+}
+void HP_clif_clearflooritem(struct flooritem_data *fitem, int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_clearflooritem_pre ) {
+		void (*preHookFunc) (struct flooritem_data *fitem, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearflooritem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_clearflooritem_pre[hIndex].func;
+			preHookFunc(fitem, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.clearflooritem(fitem, fd);
+	}
+	if( HPMHooks.count.HP_clif_clearflooritem_post ) {
+		void (*postHookFunc) (struct flooritem_data *fitem, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearflooritem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_clearflooritem_post[hIndex].func;
+			postHookFunc(fitem, &fd);
+		}
+	}
+	return;
+}
+void HP_clif_additem(struct map_session_data *sd, int n, int amount, int fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_additem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_additem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_additem_pre[hIndex].func;
+			preHookFunc(sd, &n, &amount, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.additem(sd, n, amount, fail);
+	}
+	if( HPMHooks.count.HP_clif_additem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_additem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_additem_post[hIndex].func;
+			postHookFunc(sd, &n, &amount, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_dropitem(struct map_session_data *sd, int n, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_dropitem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_dropitem_pre[hIndex].func;
+			preHookFunc(sd, &n, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.dropitem(sd, n, amount);
+	}
+	if( HPMHooks.count.HP_clif_dropitem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_dropitem_post[hIndex].func;
+			postHookFunc(sd, &n, &amount);
+		}
+	}
+	return;
+}
+void HP_clif_delitem(struct map_session_data *sd, int n, int amount, short reason) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_delitem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, short *reason);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_delitem_pre[hIndex].func;
+			preHookFunc(sd, &n, &amount, &reason);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.delitem(sd, n, amount, reason);
+	}
+	if( HPMHooks.count.HP_clif_delitem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount, short *reason);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_delitem_post[hIndex].func;
+			postHookFunc(sd, &n, &amount, &reason);
+		}
+	}
+	return;
+}
+void HP_clif_takeitem(struct block_list *src, struct block_list *dst) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_takeitem_pre ) {
+		void (*preHookFunc) (struct block_list *src, struct block_list *dst);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_takeitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_takeitem_pre[hIndex].func;
+			preHookFunc(src, dst);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.takeitem(src, dst);
+	}
+	if( HPMHooks.count.HP_clif_takeitem_post ) {
+		void (*postHookFunc) (struct block_list *src, struct block_list *dst);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_takeitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_takeitem_post[hIndex].func;
+			postHookFunc(src, dst);
+		}
+	}
+	return;
+}
+void HP_clif_arrowequip(struct map_session_data *sd, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_arrowequip_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrowequip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_arrowequip_pre[hIndex].func;
+			preHookFunc(sd, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.arrowequip(sd, val);
+	}
+	if( HPMHooks.count.HP_clif_arrowequip_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrowequip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_arrowequip_post[hIndex].func;
+			postHookFunc(sd, &val);
+		}
+	}
+	return;
+}
+void HP_clif_arrow_fail(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_arrow_fail_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_fail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_arrow_fail_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.arrow_fail(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_arrow_fail_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_fail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_arrow_fail_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_use_card(struct map_session_data *sd, int idx) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_use_card_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_use_card_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_use_card_pre[hIndex].func;
+			preHookFunc(sd, &idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.use_card(sd, idx);
+	}
+	if( HPMHooks.count.HP_clif_use_card_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_use_card_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_use_card_post[hIndex].func;
+			postHookFunc(sd, &idx);
+		}
+	}
+	return;
+}
+void HP_clif_cart_additem(struct map_session_data *sd, int n, int amount, int fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cart_additem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cart_additem_pre[hIndex].func;
+			preHookFunc(sd, &n, &amount, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cart_additem(sd, n, amount, fail);
+	}
+	if( HPMHooks.count.HP_clif_cart_additem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cart_additem_post[hIndex].func;
+			postHookFunc(sd, &n, &amount, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_cart_delitem(struct map_session_data *sd, int n, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cart_delitem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_delitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cart_delitem_pre[hIndex].func;
+			preHookFunc(sd, &n, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cart_delitem(sd, n, amount);
+	}
+	if( HPMHooks.count.HP_clif_cart_delitem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_delitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cart_delitem_post[hIndex].func;
+			postHookFunc(sd, &n, &amount);
+		}
+	}
+	return;
+}
+void HP_clif_equipitemack(struct map_session_data *sd, int n, int pos, int ok) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_equipitemack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *n, int *pos, int *ok);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equipitemack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_equipitemack_pre[hIndex].func;
+			preHookFunc(sd, &n, &pos, &ok);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.equipitemack(sd, n, pos, ok);
+	}
+	if( HPMHooks.count.HP_clif_equipitemack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *n, int *pos, int *ok);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equipitemack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_equipitemack_post[hIndex].func;
+			postHookFunc(sd, &n, &pos, &ok);
+		}
+	}
+	return;
+}
+void HP_clif_unequipitemack(struct map_session_data *sd, int n, int pos, int ok) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_unequipitemack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *n, int *pos, int *ok);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_unequipitemack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_unequipitemack_pre[hIndex].func;
+			preHookFunc(sd, &n, &pos, &ok);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.unequipitemack(sd, n, pos, ok);
+	}
+	if( HPMHooks.count.HP_clif_unequipitemack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *n, int *pos, int *ok);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_unequipitemack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_unequipitemack_post[hIndex].func;
+			postHookFunc(sd, &n, &pos, &ok);
+		}
+	}
+	return;
+}
+void HP_clif_useitemack(struct map_session_data *sd, int index, int amount, bool ok) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_useitemack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount, bool *ok);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_useitemack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_useitemack_pre[hIndex].func;
+			preHookFunc(sd, &index, &amount, &ok);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.useitemack(sd, index, amount, ok);
+	}
+	if( HPMHooks.count.HP_clif_useitemack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *index, int *amount, bool *ok);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_useitemack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_useitemack_post[hIndex].func;
+			postHookFunc(sd, &index, &amount, &ok);
+		}
+	}
+	return;
+}
+void HP_clif_addcards(unsigned char *buf, struct item *item) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_addcards_pre ) {
+		void (*preHookFunc) (unsigned char *buf, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_addcards_pre[hIndex].func;
+			preHookFunc(buf, item);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.addcards(buf, item);
+	}
+	if( HPMHooks.count.HP_clif_addcards_post ) {
+		void (*postHookFunc) (unsigned char *buf, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_addcards_post[hIndex].func;
+			postHookFunc(buf, item);
+		}
+	}
+	return;
+}
+void HP_clif_addcards2(unsigned short *cards, struct item *item) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_addcards2_pre ) {
+		void (*preHookFunc) (unsigned short *cards, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_addcards2_pre[hIndex].func;
+			preHookFunc(cards, item);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.addcards2(cards, item);
+	}
+	if( HPMHooks.count.HP_clif_addcards2_post ) {
+		void (*postHookFunc) (unsigned short *cards, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_addcards2_post[hIndex].func;
+			postHookFunc(cards, item);
+		}
+	}
+	return;
+}
+void HP_clif_item_sub(unsigned char *buf, int n, struct item *i, struct item_data *id, int equip) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_item_sub_pre ) {
+		void (*preHookFunc) (unsigned char *buf, int *n, struct item *i, struct item_data *id, int *equip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_item_sub_pre[hIndex].func;
+			preHookFunc(buf, &n, i, id, &equip);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.item_sub(buf, n, i, id, equip);
+	}
+	if( HPMHooks.count.HP_clif_item_sub_post ) {
+		void (*postHookFunc) (unsigned char *buf, int *n, struct item *i, struct item_data *id, int *equip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_item_sub_post[hIndex].func;
+			postHookFunc(buf, &n, i, id, &equip);
+		}
+	}
+	return;
+}
+void HP_clif_getareachar_item(struct map_session_data *sd, struct flooritem_data *fitem) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_getareachar_item_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct flooritem_data *fitem);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_getareachar_item_pre[hIndex].func;
+			preHookFunc(sd, fitem);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.getareachar_item(sd, fitem);
+	}
+	if( HPMHooks.count.HP_clif_getareachar_item_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct flooritem_data *fitem);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_getareachar_item_post[hIndex].func;
+			postHookFunc(sd, fitem);
+		}
+	}
+	return;
+}
+void HP_clif_cart_additem_ack(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cart_additem_ack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cart_additem_ack_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cart_additem_ack(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_cart_additem_ack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cart_additem_ack_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_cashshop_load(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cashshop_load_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_load_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cashshop_load_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cashshop_load();
+	}
+	if( HPMHooks.count.HP_clif_cashshop_load_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_load_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cashshop_load_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_clif_package_announce(struct map_session_data *sd, unsigned short nameid, unsigned short containerid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_package_announce_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *containerid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_package_announce_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_package_announce_pre[hIndex].func;
+			preHookFunc(sd, &nameid, &containerid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.package_announce(sd, nameid, containerid);
+	}
+	if( HPMHooks.count.HP_clif_package_announce_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *containerid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_package_announce_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_package_announce_post[hIndex].func;
+			postHookFunc(sd, &nameid, &containerid);
+		}
+	}
+	return;
+}
+void HP_clif_clearunit_single(int id, clr_type type, int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_clearunit_single_pre ) {
+		void (*preHookFunc) (int *id, clr_type *type, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_clearunit_single_pre[hIndex].func;
+			preHookFunc(&id, &type, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.clearunit_single(id, type, fd);
+	}
+	if( HPMHooks.count.HP_clif_clearunit_single_post ) {
+		void (*postHookFunc) (int *id, clr_type *type, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_clearunit_single_post[hIndex].func;
+			postHookFunc(&id, &type, &fd);
+		}
+	}
+	return;
+}
+void HP_clif_clearunit_area(struct block_list *bl, clr_type type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_clearunit_area_pre ) {
+		void (*preHookFunc) (struct block_list *bl, clr_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_area_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_clearunit_area_pre[hIndex].func;
+			preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.clearunit_area(bl, type);
+	}
+	if( HPMHooks.count.HP_clif_clearunit_area_post ) {
+		void (*postHookFunc) (struct block_list *bl, clr_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_area_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_clearunit_area_post[hIndex].func;
+			postHookFunc(bl, &type);
+		}
+	}
+	return;
+}
+void HP_clif_clearunit_delayed(struct block_list *bl, clr_type type, unsigned int tick) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_clearunit_delayed_pre ) {
+		void (*preHookFunc) (struct block_list *bl, clr_type *type, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_pre[hIndex].func;
+			preHookFunc(bl, &type, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.clearunit_delayed(bl, type, tick);
+	}
+	if( HPMHooks.count.HP_clif_clearunit_delayed_post ) {
+		void (*postHookFunc) (struct block_list *bl, clr_type *type, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_post[hIndex].func;
+			postHookFunc(bl, &type, &tick);
+		}
+	}
+	return;
+}
+void HP_clif_walkok(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_walkok_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_walkok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_walkok_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.walkok(sd);
+	}
+	if( HPMHooks.count.HP_clif_walkok_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_walkok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_walkok_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_move(struct unit_data *ud) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_move_pre ) {
+		void (*preHookFunc) (struct unit_data *ud);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_move_pre[hIndex].func;
+			preHookFunc(ud);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.move(ud);
+	}
+	if( HPMHooks.count.HP_clif_move_post ) {
+		void (*postHookFunc) (struct unit_data *ud);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_move_post[hIndex].func;
+			postHookFunc(ud);
+		}
+	}
+	return;
+}
+void HP_clif_move2(struct block_list *bl, struct view_data *vd, struct unit_data *ud) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_move2_pre ) {
+		void (*preHookFunc) (struct block_list *bl, struct view_data *vd, struct unit_data *ud);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_move2_pre[hIndex].func;
+			preHookFunc(bl, vd, ud);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.move2(bl, vd, ud);
+	}
+	if( HPMHooks.count.HP_clif_move2_post ) {
+		void (*postHookFunc) (struct block_list *bl, struct view_data *vd, struct unit_data *ud);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_move2_post[hIndex].func;
+			postHookFunc(bl, vd, ud);
+		}
+	}
+	return;
+}
+void HP_clif_blown(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_blown_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blown_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_blown_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.blown(bl);
+	}
+	if( HPMHooks.count.HP_clif_blown_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_blown_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_slide(struct block_list *bl, int x, int y) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_slide_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *x, int *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_slide_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_slide_pre[hIndex].func;
+			preHookFunc(bl, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.slide(bl, x, y);
+	}
+	if( HPMHooks.count.HP_clif_slide_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *x, int *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_slide_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_slide_post[hIndex].func;
+			postHookFunc(bl, &x, &y);
+		}
+	}
+	return;
+}
+void HP_clif_fixpos(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_fixpos_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fixpos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_fixpos_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.fixpos(bl);
+	}
+	if( HPMHooks.count.HP_clif_fixpos_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fixpos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_fixpos_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_changelook(struct block_list *bl, int type, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changelook_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changelook_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changelook_pre[hIndex].func;
+			preHookFunc(bl, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changelook(bl, type, val);
+	}
+	if( HPMHooks.count.HP_clif_changelook_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changelook_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changelook_post[hIndex].func;
+			postHookFunc(bl, &type, &val);
+		}
+	}
+	return;
+}
+void HP_clif_changetraplook(struct block_list *bl, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changetraplook_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changetraplook_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changetraplook_pre[hIndex].func;
+			preHookFunc(bl, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changetraplook(bl, val);
+	}
+	if( HPMHooks.count.HP_clif_changetraplook_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changetraplook_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changetraplook_post[hIndex].func;
+			postHookFunc(bl, &val);
+		}
+	}
+	return;
+}
+void HP_clif_refreshlook(struct block_list *bl, int id, int type, int val, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_refreshlook_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *id, int *type, int *val, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refreshlook_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_refreshlook_pre[hIndex].func;
+			preHookFunc(bl, &id, &type, &val, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.refreshlook(bl, id, type, val, target);
+	}
+	if( HPMHooks.count.HP_clif_refreshlook_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *id, int *type, int *val, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refreshlook_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_refreshlook_post[hIndex].func;
+			postHookFunc(bl, &id, &type, &val, &target);
+		}
+	}
+	return;
+}
+void HP_clif_class_change(struct block_list *bl, int class_, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_class_change_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *class_, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_class_change_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_class_change_pre[hIndex].func;
+			preHookFunc(bl, &class_, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.class_change(bl, class_, type);
+	}
+	if( HPMHooks.count.HP_clif_class_change_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *class_, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_class_change_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_class_change_post[hIndex].func;
+			postHookFunc(bl, &class_, &type);
+		}
+	}
+	return;
+}
+void HP_clif_skill_setunit(struct skill_unit *su) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_setunit_pre ) {
+		void (*preHookFunc) (struct skill_unit *su);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_setunit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_setunit_pre[hIndex].func;
+			preHookFunc(su);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_setunit(su);
+	}
+	if( HPMHooks.count.HP_clif_skill_setunit_post ) {
+		void (*postHookFunc) (struct skill_unit *su);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_setunit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_setunit_post[hIndex].func;
+			postHookFunc(su);
+		}
+	}
+	return;
+}
+void HP_clif_skill_delunit(struct skill_unit *su) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_delunit_pre ) {
+		void (*preHookFunc) (struct skill_unit *su);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_delunit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_delunit_pre[hIndex].func;
+			preHookFunc(su);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_delunit(su);
+	}
+	if( HPMHooks.count.HP_clif_skill_delunit_post ) {
+		void (*postHookFunc) (struct skill_unit *su);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_delunit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_delunit_post[hIndex].func;
+			postHookFunc(su);
+		}
+	}
+	return;
+}
+void HP_clif_skillunit_update(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skillunit_update_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillunit_update_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skillunit_update_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skillunit_update(bl);
+	}
+	if( HPMHooks.count.HP_clif_skillunit_update_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillunit_update_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skillunit_update_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+int HP_clif_clearunit_delayed_sub(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_clearunit_delayed_sub_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.clearunit_delayed_sub(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_clif_clearunit_delayed_sub_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_set_unit_idle(struct block_list *bl, struct map_session_data *tsd, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_set_unit_idle_pre ) {
+		void (*preHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_set_unit_idle_pre[hIndex].func;
+			preHookFunc(bl, tsd, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.set_unit_idle(bl, tsd, target);
+	}
+	if( HPMHooks.count.HP_clif_set_unit_idle_post ) {
+		void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_set_unit_idle_post[hIndex].func;
+			postHookFunc(bl, tsd, &target);
+		}
+	}
+	return;
+}
+void HP_clif_spawn_unit(struct block_list *bl, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_spawn_unit_pre ) {
+		void (*preHookFunc) (struct block_list *bl, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_spawn_unit_pre[hIndex].func;
+			preHookFunc(bl, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.spawn_unit(bl, target);
+	}
+	if( HPMHooks.count.HP_clif_spawn_unit_post ) {
+		void (*postHookFunc) (struct block_list *bl, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_spawn_unit_post[hIndex].func;
+			postHookFunc(bl, &target);
+		}
+	}
+	return;
+}
+void HP_clif_set_unit_walking(struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_set_unit_walking_pre ) {
+		void (*preHookFunc) (struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_walking_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_set_unit_walking_pre[hIndex].func;
+			preHookFunc(bl, tsd, ud, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.set_unit_walking(bl, tsd, ud, target);
+	}
+	if( HPMHooks.count.HP_clif_set_unit_walking_post ) {
+		void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_walking_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_set_unit_walking_post[hIndex].func;
+			postHookFunc(bl, tsd, ud, &target);
+		}
+	}
+	return;
+}
+int HP_clif_calc_walkdelay(struct block_list *bl, int delay, int type, int damage, int div_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_calc_walkdelay_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *delay, int *type, int *damage, int *div_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_calc_walkdelay_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_calc_walkdelay_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &delay, &type, &damage, &div_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.calc_walkdelay(bl, delay, type, damage, div_);
+	}
+	if( HPMHooks.count.HP_clif_calc_walkdelay_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *delay, int *type, int *damage, int *div_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_calc_walkdelay_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_calc_walkdelay_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &delay, &type, &damage, &div_);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_getareachar_skillunit(struct map_session_data *sd, struct skill_unit *su) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_getareachar_skillunit_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct skill_unit *su);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_skillunit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_getareachar_skillunit_pre[hIndex].func;
+			preHookFunc(sd, su);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.getareachar_skillunit(sd, su);
+	}
+	if( HPMHooks.count.HP_clif_getareachar_skillunit_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct skill_unit *su);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_skillunit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_getareachar_skillunit_post[hIndex].func;
+			postHookFunc(sd, su);
+		}
+	}
+	return;
+}
+void HP_clif_getareachar_unit(struct map_session_data *sd, struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_getareachar_unit_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_unit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_getareachar_unit_pre[hIndex].func;
+			preHookFunc(sd, bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.getareachar_unit(sd, bl);
+	}
+	if( HPMHooks.count.HP_clif_getareachar_unit_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_unit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_getareachar_unit_post[hIndex].func;
+			postHookFunc(sd, bl);
+		}
+	}
+	return;
+}
+void HP_clif_clearchar_skillunit(struct skill_unit *su, int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_clearchar_skillunit_pre ) {
+		void (*preHookFunc) (struct skill_unit *su, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchar_skillunit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_clearchar_skillunit_pre[hIndex].func;
+			preHookFunc(su, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.clearchar_skillunit(su, fd);
+	}
+	if( HPMHooks.count.HP_clif_clearchar_skillunit_post ) {
+		void (*postHookFunc) (struct skill_unit *su, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchar_skillunit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_clearchar_skillunit_post[hIndex].func;
+			postHookFunc(su, &fd);
+		}
+	}
+	return;
+}
+int HP_clif_getareachar(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_getareachar_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_clif_getareachar_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.clif.getareachar(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_clif_getareachar_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_clif_getareachar_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_spawn(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_spawn_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_spawn_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.spawn(bl);
+	}
+	if( HPMHooks.count.HP_clif_spawn_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_spawn_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_changemap(struct map_session_data *sd, short m, int x, int y) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changemap_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *m, int *x, int *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changemap_pre[hIndex].func;
+			preHookFunc(sd, &m, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changemap(sd, m, x, y);
+	}
+	if( HPMHooks.count.HP_clif_changemap_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *m, int *x, int *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changemap_post[hIndex].func;
+			postHookFunc(sd, &m, &x, &y);
+		}
+	}
+	return;
+}
+void HP_clif_changemapcell(int fd, int16 m, int x, int y, int type, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changemapcell_pre ) {
+		void (*preHookFunc) (int *fd, int16 *m, int *x, int *y, int *type, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapcell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changemapcell_pre[hIndex].func;
+			preHookFunc(&fd, &m, &x, &y, &type, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changemapcell(fd, m, x, y, type, target);
+	}
+	if( HPMHooks.count.HP_clif_changemapcell_post ) {
+		void (*postHookFunc) (int *fd, int16 *m, int *x, int *y, int *type, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapcell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changemapcell_post[hIndex].func;
+			postHookFunc(&fd, &m, &x, &y, &type, &target);
+		}
+	}
+	return;
+}
+void HP_clif_map_property(struct map_session_data *sd, enum map_property property) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_map_property_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, enum map_property *property);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_map_property_pre[hIndex].func;
+			preHookFunc(sd, &property);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.map_property(sd, property);
+	}
+	if( HPMHooks.count.HP_clif_map_property_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, enum map_property *property);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_map_property_post[hIndex].func;
+			postHookFunc(sd, &property);
+		}
+	}
+	return;
+}
+void HP_clif_pvpset(struct map_session_data *sd, int pvprank, int pvpnum, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pvpset_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *pvprank, int *pvpnum, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pvpset_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pvpset_pre[hIndex].func;
+			preHookFunc(sd, &pvprank, &pvpnum, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pvpset(sd, pvprank, pvpnum, type);
+	}
+	if( HPMHooks.count.HP_clif_pvpset_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *pvprank, int *pvpnum, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pvpset_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pvpset_post[hIndex].func;
+			postHookFunc(sd, &pvprank, &pvpnum, &type);
+		}
+	}
+	return;
+}
+void HP_clif_map_property_mapall(int mapid, enum map_property property) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_map_property_mapall_pre ) {
+		void (*preHookFunc) (int *mapid, enum map_property *property);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_mapall_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_map_property_mapall_pre[hIndex].func;
+			preHookFunc(&mapid, &property);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.map_property_mapall(mapid, property);
+	}
+	if( HPMHooks.count.HP_clif_map_property_mapall_post ) {
+		void (*postHookFunc) (int *mapid, enum map_property *property);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_mapall_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_map_property_mapall_post[hIndex].func;
+			postHookFunc(&mapid, &property);
+		}
+	}
+	return;
+}
+void HP_clif_bossmapinfo(int fd, struct mob_data *md, short flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bossmapinfo_pre ) {
+		void (*preHookFunc) (int *fd, struct mob_data *md, short *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bossmapinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bossmapinfo_pre[hIndex].func;
+			preHookFunc(&fd, md, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bossmapinfo(fd, md, flag);
+	}
+	if( HPMHooks.count.HP_clif_bossmapinfo_post ) {
+		void (*postHookFunc) (int *fd, struct mob_data *md, short *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bossmapinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bossmapinfo_post[hIndex].func;
+			postHookFunc(&fd, md, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_map_type(struct map_session_data *sd, enum map_type type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_map_type_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, enum map_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_type_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_map_type_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.map_type(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_map_type_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, enum map_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_type_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_map_type_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_maptypeproperty2(struct block_list *bl, enum send_target t) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_maptypeproperty2_pre ) {
+		void (*preHookFunc) (struct block_list *bl, enum send_target *t);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_maptypeproperty2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_maptypeproperty2_pre[hIndex].func;
+			preHookFunc(bl, &t);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.maptypeproperty2(bl, t);
+	}
+	if( HPMHooks.count.HP_clif_maptypeproperty2_post ) {
+		void (*postHookFunc) (struct block_list *bl, enum send_target *t);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_maptypeproperty2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_maptypeproperty2_post[hIndex].func;
+			postHookFunc(bl, &t);
+		}
+	}
+	return;
+}
+void HP_clif_changemapserver(struct map_session_data *sd, unsigned short map_index, int x, int y, uint32 ip, uint16 port) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changemapserver_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *map_index, int *x, int *y, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapserver_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changemapserver_pre[hIndex].func;
+			preHookFunc(sd, &map_index, &x, &y, &ip, &port);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changemapserver(sd, map_index, x, y, ip, port);
+	}
+	if( HPMHooks.count.HP_clif_changemapserver_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *map_index, int *x, int *y, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapserver_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changemapserver_post[hIndex].func;
+			postHookFunc(sd, &map_index, &x, &y, &ip, &port);
+		}
+	}
+	return;
+}
+void HP_clif_npcbuysell(struct map_session_data *sd, int id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_npcbuysell_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npcbuysell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_npcbuysell_pre[hIndex].func;
+			preHookFunc(sd, &id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.npcbuysell(sd, id);
+	}
+	if( HPMHooks.count.HP_clif_npcbuysell_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npcbuysell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_npcbuysell_post[hIndex].func;
+			postHookFunc(sd, &id);
+		}
+	}
+	return;
+}
+void HP_clif_buylist(struct map_session_data *sd, struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buylist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buylist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buylist_pre[hIndex].func;
+			preHookFunc(sd, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buylist(sd, nd);
+	}
+	if( HPMHooks.count.HP_clif_buylist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buylist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buylist_post[hIndex].func;
+			postHookFunc(sd, nd);
+		}
+	}
+	return;
+}
+void HP_clif_selllist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_selllist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_selllist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_selllist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.selllist(sd);
+	}
+	if( HPMHooks.count.HP_clif_selllist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_selllist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_selllist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_cashshop_show(struct map_session_data *sd, struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cashshop_show_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_show_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cashshop_show_pre[hIndex].func;
+			preHookFunc(sd, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cashshop_show(sd, nd);
+	}
+	if( HPMHooks.count.HP_clif_cashshop_show_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_show_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cashshop_show_post[hIndex].func;
+			postHookFunc(sd, nd);
+		}
+	}
+	return;
+}
+void HP_clif_npc_buy_result(struct map_session_data *sd, unsigned char result) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_npc_buy_result_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_buy_result_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_npc_buy_result_pre[hIndex].func;
+			preHookFunc(sd, &result);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.npc_buy_result(sd, result);
+	}
+	if( HPMHooks.count.HP_clif_npc_buy_result_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_buy_result_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_npc_buy_result_post[hIndex].func;
+			postHookFunc(sd, &result);
+		}
+	}
+	return;
+}
+void HP_clif_npc_sell_result(struct map_session_data *sd, unsigned char result) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_npc_sell_result_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_sell_result_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_npc_sell_result_pre[hIndex].func;
+			preHookFunc(sd, &result);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.npc_sell_result(sd, result);
+	}
+	if( HPMHooks.count.HP_clif_npc_sell_result_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_sell_result_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_npc_sell_result_post[hIndex].func;
+			postHookFunc(sd, &result);
+		}
+	}
+	return;
+}
+void HP_clif_cashshop_ack(struct map_session_data *sd, int error) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cashshop_ack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *error);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cashshop_ack_pre[hIndex].func;
+			preHookFunc(sd, &error);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cashshop_ack(sd, error);
+	}
+	if( HPMHooks.count.HP_clif_cashshop_ack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *error);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cashshop_ack_post[hIndex].func;
+			postHookFunc(sd, &error);
+		}
+	}
+	return;
+}
+void HP_clif_scriptmes(struct map_session_data *sd, int npcid, const char *mes) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_scriptmes_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npcid, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmes_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_scriptmes_pre[hIndex].func;
+			preHookFunc(sd, &npcid, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.scriptmes(sd, npcid, mes);
+	}
+	if( HPMHooks.count.HP_clif_scriptmes_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npcid, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmes_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_scriptmes_post[hIndex].func;
+			postHookFunc(sd, &npcid, mes);
+		}
+	}
+	return;
+}
+void HP_clif_scriptnext(struct map_session_data *sd, int npcid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_scriptnext_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptnext_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_scriptnext_pre[hIndex].func;
+			preHookFunc(sd, &npcid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.scriptnext(sd, npcid);
+	}
+	if( HPMHooks.count.HP_clif_scriptnext_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptnext_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_scriptnext_post[hIndex].func;
+			postHookFunc(sd, &npcid);
+		}
+	}
+	return;
+}
+void HP_clif_scriptclose(struct map_session_data *sd, int npcid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_scriptclose_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclose_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_scriptclose_pre[hIndex].func;
+			preHookFunc(sd, &npcid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.scriptclose(sd, npcid);
+	}
+	if( HPMHooks.count.HP_clif_scriptclose_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclose_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_scriptclose_post[hIndex].func;
+			postHookFunc(sd, &npcid);
+		}
+	}
+	return;
+}
+void HP_clif_scriptmenu(struct map_session_data *sd, int npcid, const char *mes) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_scriptmenu_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npcid, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmenu_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_scriptmenu_pre[hIndex].func;
+			preHookFunc(sd, &npcid, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.scriptmenu(sd, npcid, mes);
+	}
+	if( HPMHooks.count.HP_clif_scriptmenu_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npcid, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmenu_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_scriptmenu_post[hIndex].func;
+			postHookFunc(sd, &npcid, mes);
+		}
+	}
+	return;
+}
+void HP_clif_scriptinput(struct map_session_data *sd, int npcid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_scriptinput_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinput_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_scriptinput_pre[hIndex].func;
+			preHookFunc(sd, &npcid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.scriptinput(sd, npcid);
+	}
+	if( HPMHooks.count.HP_clif_scriptinput_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinput_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_scriptinput_post[hIndex].func;
+			postHookFunc(sd, &npcid);
+		}
+	}
+	return;
+}
+void HP_clif_scriptinputstr(struct map_session_data *sd, int npcid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_scriptinputstr_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinputstr_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_scriptinputstr_pre[hIndex].func;
+			preHookFunc(sd, &npcid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.scriptinputstr(sd, npcid);
+	}
+	if( HPMHooks.count.HP_clif_scriptinputstr_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinputstr_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_scriptinputstr_post[hIndex].func;
+			postHookFunc(sd, &npcid);
+		}
+	}
+	return;
+}
+void HP_clif_cutin(struct map_session_data *sd, const char *image, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cutin_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *image, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cutin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cutin_pre[hIndex].func;
+			preHookFunc(sd, image, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cutin(sd, image, type);
+	}
+	if( HPMHooks.count.HP_clif_cutin_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *image, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cutin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cutin_post[hIndex].func;
+			postHookFunc(sd, image, &type);
+		}
+	}
+	return;
+}
+void HP_clif_sendfakenpc(struct map_session_data *sd, int npcid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_sendfakenpc_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendfakenpc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_sendfakenpc_pre[hIndex].func;
+			preHookFunc(sd, &npcid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.sendfakenpc(sd, npcid);
+	}
+	if( HPMHooks.count.HP_clif_sendfakenpc_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendfakenpc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_sendfakenpc_post[hIndex].func;
+			postHookFunc(sd, &npcid);
+		}
+	}
+	return;
+}
+void HP_clif_scriptclear(struct map_session_data *sd, int npcid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_scriptclear_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_scriptclear_pre[hIndex].func;
+			preHookFunc(sd, &npcid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.scriptclear(sd, npcid);
+	}
+	if( HPMHooks.count.HP_clif_scriptclear_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_scriptclear_post[hIndex].func;
+			postHookFunc(sd, &npcid);
+		}
+	}
+	return;
+}
+void HP_clif_viewpoint(struct map_session_data *sd, int npc_id, int type, int x, int y, int id, int color) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_viewpoint_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *npc_id, int *type, int *x, int *y, int *id, int *color);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewpoint_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_viewpoint_pre[hIndex].func;
+			preHookFunc(sd, &npc_id, &type, &x, &y, &id, &color);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.viewpoint(sd, npc_id, type, x, y, id, color);
+	}
+	if( HPMHooks.count.HP_clif_viewpoint_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *npc_id, int *type, int *x, int *y, int *id, int *color);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewpoint_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_viewpoint_post[hIndex].func;
+			postHookFunc(sd, &npc_id, &type, &x, &y, &id, &color);
+		}
+	}
+	return;
+}
+int HP_clif_damage(struct block_list *src, struct block_list *dst, unsigned int tick, int sdelay, int ddelay, int64 damage, int div, int type, int64 damage2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_damage_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *dst, unsigned int *tick, int *sdelay, int *ddelay, int64 *damage, int *div, int *type, int64 *damage2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, dst, &tick, &sdelay, &ddelay, &damage, &div, &type, &damage2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.damage(src, dst, tick, sdelay, ddelay, damage, div, type, damage2);
+	}
+	if( HPMHooks.count.HP_clif_damage_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, unsigned int *tick, int *sdelay, int *ddelay, int64 *damage, int *div, int *type, int64 *damage2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, dst, &tick, &sdelay, &ddelay, &damage, &div, &type, &damage2);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_sitting(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_sitting_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sitting_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_sitting_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.sitting(bl);
+	}
+	if( HPMHooks.count.HP_clif_sitting_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sitting_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_sitting_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_standing(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_standing_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_standing_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_standing_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.standing(bl);
+	}
+	if( HPMHooks.count.HP_clif_standing_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_standing_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_standing_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_arrow_create_list(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_arrow_create_list_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_create_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_arrow_create_list_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.arrow_create_list(sd);
+	}
+	if( HPMHooks.count.HP_clif_arrow_create_list_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_create_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_arrow_create_list_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_refresh(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_refresh_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_refresh_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.refresh(sd);
+	}
+	if( HPMHooks.count.HP_clif_refresh_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_refresh_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_fame_blacksmith(struct map_session_data *sd, int points) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_fame_blacksmith_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_blacksmith_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_fame_blacksmith_pre[hIndex].func;
+			preHookFunc(sd, &points);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.fame_blacksmith(sd, points);
+	}
+	if( HPMHooks.count.HP_clif_fame_blacksmith_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_blacksmith_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_fame_blacksmith_post[hIndex].func;
+			postHookFunc(sd, &points);
+		}
+	}
+	return;
+}
+void HP_clif_fame_alchemist(struct map_session_data *sd, int points) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_fame_alchemist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_alchemist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_fame_alchemist_pre[hIndex].func;
+			preHookFunc(sd, &points);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.fame_alchemist(sd, points);
+	}
+	if( HPMHooks.count.HP_clif_fame_alchemist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_alchemist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_fame_alchemist_post[hIndex].func;
+			postHookFunc(sd, &points);
+		}
+	}
+	return;
+}
+void HP_clif_fame_taekwon(struct map_session_data *sd, int points) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_fame_taekwon_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_taekwon_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_fame_taekwon_pre[hIndex].func;
+			preHookFunc(sd, &points);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.fame_taekwon(sd, points);
+	}
+	if( HPMHooks.count.HP_clif_fame_taekwon_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_taekwon_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_fame_taekwon_post[hIndex].func;
+			postHookFunc(sd, &points);
+		}
+	}
+	return;
+}
+void HP_clif_ranklist(struct map_session_data *sd, enum fame_list_type type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_ranklist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, enum fame_list_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranklist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_ranklist_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.ranklist(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_ranklist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, enum fame_list_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranklist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_ranklist_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_update_rankingpoint(struct map_session_data *sd, enum fame_list_type type, int points) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_update_rankingpoint_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, enum fame_list_type *type, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_update_rankingpoint_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_update_rankingpoint_pre[hIndex].func;
+			preHookFunc(sd, &type, &points);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.update_rankingpoint(sd, type, points);
+	}
+	if( HPMHooks.count.HP_clif_update_rankingpoint_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, enum fame_list_type *type, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_update_rankingpoint_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_update_rankingpoint_post[hIndex].func;
+			postHookFunc(sd, &type, &points);
+		}
+	}
+	return;
+}
+void HP_clif_pRanklist(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pRanklist_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRanklist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pRanklist_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pRanklist(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pRanklist_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRanklist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pRanklist_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_hotkeys(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_hotkeys_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hotkeys_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_hotkeys_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.hotkeys(sd);
+	}
+	if( HPMHooks.count.HP_clif_hotkeys_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hotkeys_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_hotkeys_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_clif_insight(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_insight_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insight_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_clif_insight_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.clif.insight(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_clif_insight_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insight_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_clif_insight_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_outsight(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_outsight_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_outsight_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_clif_outsight_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.clif.outsight(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_clif_outsight_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_outsight_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_clif_outsight_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_skillcastcancel(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skillcastcancel_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcastcancel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skillcastcancel_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skillcastcancel(bl);
+	}
+	if( HPMHooks.count.HP_clif_skillcastcancel_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcastcancel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skillcastcancel_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_skill_fail(struct map_session_data *sd, uint16 skill_id, enum useskill_fail_cause cause, int btype) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_fail_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, enum useskill_fail_cause *cause, int *btype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_fail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_fail_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &cause, &btype);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_fail(sd, skill_id, cause, btype);
+	}
+	if( HPMHooks.count.HP_clif_skill_fail_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, enum useskill_fail_cause *cause, int *btype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_fail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_fail_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &cause, &btype);
+		}
+	}
+	return;
+}
+void HP_clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsigned int tick) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_cooldown_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_cooldown_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_cooldown_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_cooldown(sd, skill_id, tick);
+	}
+	if( HPMHooks.count.HP_clif_skill_cooldown_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_cooldown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_cooldown_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &tick);
+		}
+	}
+	return;
+}
+void HP_clif_skill_memomessage(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_memomessage_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_memomessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_memomessage_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_memomessage(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_skill_memomessage_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_memomessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_memomessage_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_skill_mapinfomessage(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_mapinfomessage_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_mapinfomessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_mapinfomessage_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_mapinfomessage(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_skill_mapinfomessage_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_mapinfomessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_mapinfomessage_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_skill_produce_mix_list(struct map_session_data *sd, int skill_id, int trigger) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_produce_mix_list_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *skill_id, int *trigger);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_produce_mix_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_produce_mix_list_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &trigger);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_produce_mix_list(sd, skill_id, trigger);
+	}
+	if( HPMHooks.count.HP_clif_skill_produce_mix_list_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *skill_id, int *trigger);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_produce_mix_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_produce_mix_list_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &trigger);
+		}
+	}
+	return;
+}
+void HP_clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill_id, int qty, int list_type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cooking_list_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *trigger, uint16 *skill_id, int *qty, int *list_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooking_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cooking_list_pre[hIndex].func;
+			preHookFunc(sd, &trigger, &skill_id, &qty, &list_type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cooking_list(sd, trigger, skill_id, qty, list_type);
+	}
+	if( HPMHooks.count.HP_clif_cooking_list_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *trigger, uint16 *skill_id, int *qty, int *list_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooking_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cooking_list_post[hIndex].func;
+			postHookFunc(sd, &trigger, &skill_id, &qty, &list_type);
+		}
+	}
+	return;
+}
+void HP_clif_autospell(struct map_session_data *sd, uint16 skill_lv) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_autospell_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autospell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_autospell_pre[hIndex].func;
+			preHookFunc(sd, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.autospell(sd, skill_lv);
+	}
+	if( HPMHooks.count.HP_clif_autospell_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autospell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_autospell_post[hIndex].func;
+			postHookFunc(sd, &skill_lv);
+		}
+	}
+	return;
+}
+void HP_clif_combo_delay(struct block_list *bl, int wait) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_combo_delay_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *wait);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_combo_delay_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_combo_delay_pre[hIndex].func;
+			preHookFunc(bl, &wait);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.combo_delay(bl, wait);
+	}
+	if( HPMHooks.count.HP_clif_combo_delay_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *wait);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_combo_delay_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_combo_delay_post[hIndex].func;
+			postHookFunc(bl, &wait);
+		}
+	}
+	return;
+}
+void HP_clif_status_change(struct block_list *bl, int type, int flag, int tick, int val1, int val2, int val3) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_status_change_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *type, int *flag, int *tick, int *val1, int *val2, int *val3);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_status_change_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_status_change_pre[hIndex].func;
+			preHookFunc(bl, &type, &flag, &tick, &val1, &val2, &val3);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.status_change(bl, type, flag, tick, val1, val2, val3);
+	}
+	if( HPMHooks.count.HP_clif_status_change_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *type, int *flag, int *tick, int *val1, int *val2, int *val3);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_status_change_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_status_change_post[hIndex].func;
+			postHookFunc(bl, &type, &flag, &tick, &val1, &val2, &val3);
+		}
+	}
+	return;
+}
+void HP_clif_insert_card(struct map_session_data *sd, int idx_equip, int idx_card, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_insert_card_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *idx_equip, int *idx_card, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insert_card_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_insert_card_pre[hIndex].func;
+			preHookFunc(sd, &idx_equip, &idx_card, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.insert_card(sd, idx_equip, idx_card, flag);
+	}
+	if( HPMHooks.count.HP_clif_insert_card_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *idx_equip, int *idx_card, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insert_card_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_insert_card_post[hIndex].func;
+			postHookFunc(sd, &idx_equip, &idx_card, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_inventorylist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_inventorylist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_inventorylist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_inventorylist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.inventorylist(sd);
+	}
+	if( HPMHooks.count.HP_clif_inventorylist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_inventorylist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_inventorylist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_equiplist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_equiplist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiplist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_equiplist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.equiplist(sd);
+	}
+	if( HPMHooks.count.HP_clif_equiplist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiplist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_equiplist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_cartlist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cartlist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cartlist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cartlist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cartlist(sd);
+	}
+	if( HPMHooks.count.HP_clif_cartlist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cartlist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cartlist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_favorite_item(struct map_session_data *sd, unsigned short index) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_favorite_item_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_favorite_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_favorite_item_pre[hIndex].func;
+			preHookFunc(sd, &index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.favorite_item(sd, index);
+	}
+	if( HPMHooks.count.HP_clif_favorite_item_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_favorite_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_favorite_item_post[hIndex].func;
+			postHookFunc(sd, &index);
+		}
+	}
+	return;
+}
+void HP_clif_clearcart(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_clearcart_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearcart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_clearcart_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.clearcart(fd);
+	}
+	if( HPMHooks.count.HP_clif_clearcart_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearcart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_clearcart_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_clif_item_identify_list(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_item_identify_list_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identify_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_item_identify_list_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.item_identify_list(sd);
+	}
+	if( HPMHooks.count.HP_clif_item_identify_list_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identify_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_item_identify_list_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_item_identified(struct map_session_data *sd, int idx, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_item_identified_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *idx, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identified_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_item_identified_pre[hIndex].func;
+			preHookFunc(sd, &idx, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.item_identified(sd, idx, flag);
+	}
+	if( HPMHooks.count.HP_clif_item_identified_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *idx, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identified_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_item_identified_post[hIndex].func;
+			postHookFunc(sd, &idx, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_item_repair_list(struct map_session_data *sd, struct map_session_data *dstsd, int lv) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_item_repair_list_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repair_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_item_repair_list_pre[hIndex].func;
+			preHookFunc(sd, dstsd, &lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.item_repair_list(sd, dstsd, lv);
+	}
+	if( HPMHooks.count.HP_clif_item_repair_list_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repair_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_item_repair_list_post[hIndex].func;
+			postHookFunc(sd, dstsd, &lv);
+		}
+	}
+	return;
+}
+void HP_clif_item_repaireffect(struct map_session_data *sd, int idx, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_item_repaireffect_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *idx, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repaireffect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_item_repaireffect_pre[hIndex].func;
+			preHookFunc(sd, &idx, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.item_repaireffect(sd, idx, flag);
+	}
+	if( HPMHooks.count.HP_clif_item_repaireffect_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *idx, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repaireffect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_item_repaireffect_post[hIndex].func;
+			postHookFunc(sd, &idx, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_item_damaged(struct map_session_data *sd, unsigned short position) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_item_damaged_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *position);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_damaged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_item_damaged_pre[hIndex].func;
+			preHookFunc(sd, &position);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.item_damaged(sd, position);
+	}
+	if( HPMHooks.count.HP_clif_item_damaged_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *position);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_damaged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_item_damaged_post[hIndex].func;
+			postHookFunc(sd, &position);
+		}
+	}
+	return;
+}
+void HP_clif_item_refine_list(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_item_refine_list_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_refine_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_item_refine_list_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.item_refine_list(sd);
+	}
+	if( HPMHooks.count.HP_clif_item_refine_list_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_refine_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_item_refine_list_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_item_skill(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_item_skill_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_skill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_item_skill_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.item_skill(sd, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_clif_item_skill_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_skill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_item_skill_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &skill_lv);
+		}
+	}
+	return;
+}
+void HP_clif_mvp_item(struct map_session_data *sd, int nameid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mvp_item_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mvp_item_pre[hIndex].func;
+			preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mvp_item(sd, nameid);
+	}
+	if( HPMHooks.count.HP_clif_mvp_item_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mvp_item_post[hIndex].func;
+			postHookFunc(sd, &nameid);
+		}
+	}
+	return;
+}
+void HP_clif_mvp_exp(struct map_session_data *sd, unsigned int exp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mvp_exp_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *exp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_exp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mvp_exp_pre[hIndex].func;
+			preHookFunc(sd, &exp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mvp_exp(sd, exp);
+	}
+	if( HPMHooks.count.HP_clif_mvp_exp_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *exp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_exp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mvp_exp_post[hIndex].func;
+			postHookFunc(sd, &exp);
+		}
+	}
+	return;
+}
+void HP_clif_mvp_noitem(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mvp_noitem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_noitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mvp_noitem_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mvp_noitem(sd);
+	}
+	if( HPMHooks.count.HP_clif_mvp_noitem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_noitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mvp_noitem_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_changed_dir(struct block_list *bl, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changed_dir_pre ) {
+		void (*preHookFunc) (struct block_list *bl, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changed_dir_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changed_dir_pre[hIndex].func;
+			preHookFunc(bl, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changed_dir(bl, target);
+	}
+	if( HPMHooks.count.HP_clif_changed_dir_post ) {
+		void (*postHookFunc) (struct block_list *bl, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changed_dir_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changed_dir_post[hIndex].func;
+			postHookFunc(bl, &target);
+		}
+	}
+	return;
+}
+void HP_clif_charnameack(int fd, struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_charnameack_pre ) {
+		void (*preHookFunc) (int *fd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_charnameack_pre[hIndex].func;
+			preHookFunc(&fd, bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.charnameack(fd, bl);
+	}
+	if( HPMHooks.count.HP_clif_charnameack_post ) {
+		void (*postHookFunc) (int *fd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_charnameack_post[hIndex].func;
+			postHookFunc(&fd, bl);
+		}
+	}
+	return;
+}
+void HP_clif_monster_hp_bar(struct mob_data *md, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_monster_hp_bar_pre ) {
+		void (*preHookFunc) (struct mob_data *md, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_monster_hp_bar_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_monster_hp_bar_pre[hIndex].func;
+			preHookFunc(md, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.monster_hp_bar(md, sd);
+	}
+	if( HPMHooks.count.HP_clif_monster_hp_bar_post ) {
+		void (*postHookFunc) (struct mob_data *md, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_monster_hp_bar_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_monster_hp_bar_post[hIndex].func;
+			postHookFunc(md, sd);
+		}
+	}
+	return;
+}
+int HP_clif_hpmeter(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_hpmeter_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_hpmeter_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.hpmeter(sd);
+	}
+	if( HPMHooks.count.HP_clif_hpmeter_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_hpmeter_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_hpmeter_single(int fd, int id, unsigned int hp, unsigned int maxhp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_hpmeter_single_pre ) {
+		void (*preHookFunc) (int *fd, int *id, unsigned int *hp, unsigned int *maxhp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_hpmeter_single_pre[hIndex].func;
+			preHookFunc(&fd, &id, &hp, &maxhp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.hpmeter_single(fd, id, hp, maxhp);
+	}
+	if( HPMHooks.count.HP_clif_hpmeter_single_post ) {
+		void (*postHookFunc) (int *fd, int *id, unsigned int *hp, unsigned int *maxhp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_hpmeter_single_post[hIndex].func;
+			postHookFunc(&fd, &id, &hp, &maxhp);
+		}
+	}
+	return;
+}
+int HP_clif_hpmeter_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_hpmeter_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_clif_hpmeter_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.clif.hpmeter_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_clif_hpmeter_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_clif_hpmeter_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_upgrademessage(int fd, int result, int item_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_upgrademessage_pre ) {
+		void (*preHookFunc) (int *fd, int *result, int *item_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_upgrademessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_upgrademessage_pre[hIndex].func;
+			preHookFunc(&fd, &result, &item_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.upgrademessage(fd, result, item_id);
+	}
+	if( HPMHooks.count.HP_clif_upgrademessage_post ) {
+		void (*postHookFunc) (int *fd, int *result, int *item_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_upgrademessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_upgrademessage_post[hIndex].func;
+			postHookFunc(&fd, &result, &item_id);
+		}
+	}
+	return;
+}
+void HP_clif_get_weapon_view(struct map_session_data *sd, unsigned short *rhand, unsigned short *lhand) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_get_weapon_view_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *rhand, unsigned short *lhand);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_get_weapon_view_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_get_weapon_view_pre[hIndex].func;
+			preHookFunc(sd, rhand, lhand);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.get_weapon_view(sd, rhand, lhand);
+	}
+	if( HPMHooks.count.HP_clif_get_weapon_view_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *rhand, unsigned short *lhand);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_get_weapon_view_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_get_weapon_view_post[hIndex].func;
+			postHookFunc(sd, rhand, lhand);
+		}
+	}
+	return;
+}
+void HP_clif_gospel_info(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_gospel_info_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_gospel_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_gospel_info_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.gospel_info(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_gospel_info_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_gospel_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_gospel_info_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_feel_req(int fd, struct map_session_data *sd, uint16 skill_lv) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_feel_req_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_req_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_feel_req_pre[hIndex].func;
+			preHookFunc(&fd, sd, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.feel_req(fd, sd, skill_lv);
+	}
+	if( HPMHooks.count.HP_clif_feel_req_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_req_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_feel_req_post[hIndex].func;
+			postHookFunc(&fd, sd, &skill_lv);
+		}
+	}
+	return;
+}
+void HP_clif_starskill(struct map_session_data *sd, const char *mapname, int monster_id, unsigned char star, unsigned char result) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_starskill_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *mapname, int *monster_id, unsigned char *star, unsigned char *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_starskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_starskill_pre[hIndex].func;
+			preHookFunc(sd, mapname, &monster_id, &star, &result);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.starskill(sd, mapname, monster_id, star, result);
+	}
+	if( HPMHooks.count.HP_clif_starskill_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *mapname, int *monster_id, unsigned char *star, unsigned char *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_starskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_starskill_post[hIndex].func;
+			postHookFunc(sd, mapname, &monster_id, &star, &result);
+		}
+	}
+	return;
+}
+void HP_clif_feel_info(struct map_session_data *sd, unsigned char feel_level, unsigned char type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_feel_info_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *feel_level, unsigned char *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_feel_info_pre[hIndex].func;
+			preHookFunc(sd, &feel_level, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.feel_info(sd, feel_level, type);
+	}
+	if( HPMHooks.count.HP_clif_feel_info_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *feel_level, unsigned char *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_feel_info_post[hIndex].func;
+			postHookFunc(sd, &feel_level, &type);
+		}
+	}
+	return;
+}
+void HP_clif_hate_info(struct map_session_data *sd, unsigned char hate_level, int class_, unsigned char type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_hate_info_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *hate_level, int *class_, unsigned char *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hate_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_hate_info_pre[hIndex].func;
+			preHookFunc(sd, &hate_level, &class_, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.hate_info(sd, hate_level, class_, type);
+	}
+	if( HPMHooks.count.HP_clif_hate_info_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *hate_level, int *class_, unsigned char *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hate_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_hate_info_post[hIndex].func;
+			postHookFunc(sd, &hate_level, &class_, &type);
+		}
+	}
+	return;
+}
+void HP_clif_mission_info(struct map_session_data *sd, int mob_id, unsigned char progress) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mission_info_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *mob_id, unsigned char *progress);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mission_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mission_info_pre[hIndex].func;
+			preHookFunc(sd, &mob_id, &progress);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mission_info(sd, mob_id, progress);
+	}
+	if( HPMHooks.count.HP_clif_mission_info_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *mob_id, unsigned char *progress);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mission_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mission_info_post[hIndex].func;
+			postHookFunc(sd, &mob_id, &progress);
+		}
+	}
+	return;
+}
+void HP_clif_feel_hate_reset(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_feel_hate_reset_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_hate_reset_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_feel_hate_reset_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.feel_hate_reset(sd);
+	}
+	if( HPMHooks.count.HP_clif_feel_hate_reset_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_hate_reset_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_feel_hate_reset_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_partytickack(struct map_session_data *sd, bool flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_partytickack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partytickack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_partytickack_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.partytickack(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_partytickack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partytickack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_partytickack_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_equiptickack(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_equiptickack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiptickack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_equiptickack_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.equiptickack(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_equiptickack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiptickack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_equiptickack_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_viewequip_ack(struct map_session_data *sd, struct map_session_data *tsd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_viewequip_ack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewequip_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_viewequip_ack_pre[hIndex].func;
+			preHookFunc(sd, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.viewequip_ack(sd, tsd);
+	}
+	if( HPMHooks.count.HP_clif_viewequip_ack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewequip_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_viewequip_ack_post[hIndex].func;
+			postHookFunc(sd, tsd);
+		}
+	}
+	return;
+}
+void HP_clif_viewequip_fail(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_viewequip_fail_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewequip_fail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_viewequip_fail_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.viewequip_fail(sd);
+	}
+	if( HPMHooks.count.HP_clif_viewequip_fail_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewequip_fail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_viewequip_fail_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_equpcheckbox(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_equpcheckbox_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equpcheckbox_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_equpcheckbox_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.equpcheckbox(sd);
+	}
+	if( HPMHooks.count.HP_clif_equpcheckbox_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equpcheckbox_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_equpcheckbox_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_displayexp(struct map_session_data *sd, unsigned int exp, char type, bool is_quest) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_displayexp_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *exp, char *type, bool *is_quest);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_displayexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_displayexp_pre[hIndex].func;
+			preHookFunc(sd, &exp, &type, &is_quest);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.displayexp(sd, exp, type, is_quest);
+	}
+	if( HPMHooks.count.HP_clif_displayexp_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *exp, char *type, bool *is_quest);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_displayexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_displayexp_post[hIndex].func;
+			postHookFunc(sd, &exp, &type, &is_quest);
+		}
+	}
+	return;
+}
+void HP_clif_font(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_font_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_font_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_font_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.font(sd);
+	}
+	if( HPMHooks.count.HP_clif_font_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_font_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_font_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_progressbar(struct map_session_data *sd, unsigned long color, unsigned int second) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_progressbar_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned long *color, unsigned int *second);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_progressbar_pre[hIndex].func;
+			preHookFunc(sd, &color, &second);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.progressbar(sd, color, second);
+	}
+	if( HPMHooks.count.HP_clif_progressbar_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned long *color, unsigned int *second);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_progressbar_post[hIndex].func;
+			postHookFunc(sd, &color, &second);
+		}
+	}
+	return;
+}
+void HP_clif_progressbar_abort(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_progressbar_abort_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_abort_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_progressbar_abort_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.progressbar_abort(sd);
+	}
+	if( HPMHooks.count.HP_clif_progressbar_abort_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_abort_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_progressbar_abort_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_showdigit(struct map_session_data *sd, unsigned char type, int value) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_showdigit_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *type, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showdigit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_showdigit_pre[hIndex].func;
+			preHookFunc(sd, &type, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.showdigit(sd, type, value);
+	}
+	if( HPMHooks.count.HP_clif_showdigit_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *type, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showdigit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_showdigit_post[hIndex].func;
+			postHookFunc(sd, &type, &value);
+		}
+	}
+	return;
+}
+int HP_clif_elementalconverter_list(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_elementalconverter_list_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elementalconverter_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_elementalconverter_list_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.elementalconverter_list(sd);
+	}
+	if( HPMHooks.count.HP_clif_elementalconverter_list_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elementalconverter_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_elementalconverter_list_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_spellbook_list(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_spellbook_list_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spellbook_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_spellbook_list_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.spellbook_list(sd);
+	}
+	if( HPMHooks.count.HP_clif_spellbook_list_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spellbook_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_spellbook_list_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_magicdecoy_list(struct map_session_data *sd, uint16 skill_lv, short x, short y) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_magicdecoy_list_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_magicdecoy_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_magicdecoy_list_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_lv, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.magicdecoy_list(sd, skill_lv, x, y);
+	}
+	if( HPMHooks.count.HP_clif_magicdecoy_list_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_lv, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_magicdecoy_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_magicdecoy_list_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_lv, &x, &y);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_poison_list(struct map_session_data *sd, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_poison_list_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_poison_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_poison_list_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.poison_list(sd, skill_lv);
+	}
+	if( HPMHooks.count.HP_clif_poison_list_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_poison_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_poison_list_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_autoshadowspell_list(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_autoshadowspell_list_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autoshadowspell_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_autoshadowspell_list_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.autoshadowspell_list(sd);
+	}
+	if( HPMHooks.count.HP_clif_autoshadowspell_list_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autoshadowspell_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_autoshadowspell_list_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_skill_itemlistwindow(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_skill_itemlistwindow_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_itemlistwindow_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_itemlistwindow_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.skill_itemlistwindow(sd, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_clif_skill_itemlistwindow_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_itemlistwindow_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_itemlistwindow_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_sc_load(struct block_list *bl, int tid, enum send_target target, int type, int val1, int val2, int val3) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_sc_load_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *tid, enum send_target *target, int *type, int *val1, int *val2, int *val3);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_load_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_sc_load_pre[hIndex].func;
+			preHookFunc(bl, &tid, &target, &type, &val1, &val2, &val3);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.sc_load(bl, tid, target, type, val1, val2, val3);
+	}
+	if( HPMHooks.count.HP_clif_sc_load_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *tid, enum send_target *target, int *type, int *val1, int *val2, int *val3);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_load_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_sc_load_post[hIndex].func;
+			postHookFunc(bl, &tid, &target, &type, &val1, &val2, &val3);
+		}
+	}
+	return;
+}
+void HP_clif_sc_end(struct block_list *bl, int tid, enum send_target target, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_sc_end_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *tid, enum send_target *target, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_sc_end_pre[hIndex].func;
+			preHookFunc(bl, &tid, &target, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.sc_end(bl, tid, target, type);
+	}
+	if( HPMHooks.count.HP_clif_sc_end_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *tid, enum send_target *target, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_sc_end_post[hIndex].func;
+			postHookFunc(bl, &tid, &target, &type);
+		}
+	}
+	return;
+}
+void HP_clif_initialstatus(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_initialstatus_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_initialstatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_initialstatus_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.initialstatus(sd);
+	}
+	if( HPMHooks.count.HP_clif_initialstatus_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_initialstatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_initialstatus_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_cooldown_list(int fd, struct skill_cd *cd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_cooldown_list_pre ) {
+		void (*preHookFunc) (int *fd, struct skill_cd *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooldown_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_cooldown_list_pre[hIndex].func;
+			preHookFunc(&fd, cd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.cooldown_list(fd, cd);
+	}
+	if( HPMHooks.count.HP_clif_cooldown_list_post ) {
+		void (*postHookFunc) (int *fd, struct skill_cd *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooldown_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_cooldown_list_post[hIndex].func;
+			postHookFunc(&fd, cd);
+		}
+	}
+	return;
+}
+void HP_clif_updatestatus(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_updatestatus_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_updatestatus_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.updatestatus(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_updatestatus_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_updatestatus_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_changestatus(struct map_session_data *sd, int type, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changestatus_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changestatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changestatus_pre[hIndex].func;
+			preHookFunc(sd, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changestatus(sd, type, val);
+	}
+	if( HPMHooks.count.HP_clif_changestatus_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changestatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changestatus_post[hIndex].func;
+			postHookFunc(sd, &type, &val);
+		}
+	}
+	return;
+}
+void HP_clif_statusupack(struct map_session_data *sd, int type, int ok, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_statusupack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type, int *ok, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_statusupack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_statusupack_pre[hIndex].func;
+			preHookFunc(sd, &type, &ok, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.statusupack(sd, type, ok, val);
+	}
+	if( HPMHooks.count.HP_clif_statusupack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type, int *ok, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_statusupack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_statusupack_post[hIndex].func;
+			postHookFunc(sd, &type, &ok, &val);
+		}
+	}
+	return;
+}
+void HP_clif_movetoattack(struct map_session_data *sd, struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_movetoattack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_movetoattack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_movetoattack_pre[hIndex].func;
+			preHookFunc(sd, bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.movetoattack(sd, bl);
+	}
+	if( HPMHooks.count.HP_clif_movetoattack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_movetoattack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_movetoattack_post[hIndex].func;
+			postHookFunc(sd, bl);
+		}
+	}
+	return;
+}
+void HP_clif_solved_charname(int fd, int charid, const char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_solved_charname_pre ) {
+		void (*preHookFunc) (int *fd, int *charid, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_solved_charname_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_solved_charname_pre[hIndex].func;
+			preHookFunc(&fd, &charid, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.solved_charname(fd, charid, name);
+	}
+	if( HPMHooks.count.HP_clif_solved_charname_post ) {
+		void (*postHookFunc) (int *fd, int *charid, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_solved_charname_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_solved_charname_post[hIndex].func;
+			postHookFunc(&fd, &charid, name);
+		}
+	}
+	return;
+}
+void HP_clif_charnameupdate(struct map_session_data *ssd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_charnameupdate_pre ) {
+		void (*preHookFunc) (struct map_session_data *ssd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameupdate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_charnameupdate_pre[hIndex].func;
+			preHookFunc(ssd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.charnameupdate(ssd);
+	}
+	if( HPMHooks.count.HP_clif_charnameupdate_post ) {
+		void (*postHookFunc) (struct map_session_data *ssd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameupdate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_charnameupdate_post[hIndex].func;
+			postHookFunc(ssd);
+		}
+	}
+	return;
+}
+int HP_clif_delayquit(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_delayquit_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delayquit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_delayquit_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.delayquit(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_clif_delayquit_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delayquit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_delayquit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_getareachar_pc(struct map_session_data *sd, struct map_session_data *dstsd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_getareachar_pc_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_pc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_getareachar_pc_pre[hIndex].func;
+			preHookFunc(sd, dstsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.getareachar_pc(sd, dstsd);
+	}
+	if( HPMHooks.count.HP_clif_getareachar_pc_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_pc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_getareachar_pc_post[hIndex].func;
+			postHookFunc(sd, dstsd);
+		}
+	}
+	return;
+}
+void HP_clif_disconnect_ack(struct map_session_data *sd, short result) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_disconnect_ack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disconnect_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_disconnect_ack_pre[hIndex].func;
+			preHookFunc(sd, &result);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.disconnect_ack(sd, result);
+	}
+	if( HPMHooks.count.HP_clif_disconnect_ack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disconnect_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_disconnect_ack_post[hIndex].func;
+			postHookFunc(sd, &result);
+		}
+	}
+	return;
+}
+void HP_clif_PVPInfo(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PVPInfo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PVPInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PVPInfo_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PVPInfo(sd);
+	}
+	if( HPMHooks.count.HP_clif_PVPInfo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PVPInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PVPInfo_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_blacksmith(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_blacksmith_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blacksmith_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_blacksmith_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.blacksmith(sd);
+	}
+	if( HPMHooks.count.HP_clif_blacksmith_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blacksmith_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_blacksmith_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_alchemist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_alchemist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_alchemist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_alchemist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.alchemist(sd);
+	}
+	if( HPMHooks.count.HP_clif_alchemist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_alchemist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_alchemist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_taekwon(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_taekwon_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_taekwon_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_taekwon_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.taekwon(sd);
+	}
+	if( HPMHooks.count.HP_clif_taekwon_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_taekwon_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_taekwon_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_ranking_pk(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_ranking_pk_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranking_pk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_ranking_pk_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.ranking_pk(sd);
+	}
+	if( HPMHooks.count.HP_clif_ranking_pk_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranking_pk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_ranking_pk_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_quitsave(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_quitsave_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quitsave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_quitsave_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.quitsave(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_quitsave_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quitsave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_quitsave_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_misceffect(struct block_list *bl, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_misceffect_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_misceffect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_misceffect_pre[hIndex].func;
+			preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.misceffect(bl, type);
+	}
+	if( HPMHooks.count.HP_clif_misceffect_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_misceffect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_misceffect_post[hIndex].func;
+			postHookFunc(bl, &type);
+		}
+	}
+	return;
+}
+void HP_clif_changeoption(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changeoption_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changeoption_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changeoption(bl);
+	}
+	if( HPMHooks.count.HP_clif_changeoption_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changeoption_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_changeoption2(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changeoption2_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changeoption2_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changeoption2(bl);
+	}
+	if( HPMHooks.count.HP_clif_changeoption2_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changeoption2_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_emotion(struct block_list *bl, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_emotion_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_emotion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_emotion_pre[hIndex].func;
+			preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.emotion(bl, type);
+	}
+	if( HPMHooks.count.HP_clif_emotion_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_emotion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_emotion_post[hIndex].func;
+			postHookFunc(bl, &type);
+		}
+	}
+	return;
+}
+void HP_clif_talkiebox(struct block_list *bl, const char *talkie) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_talkiebox_pre ) {
+		void (*preHookFunc) (struct block_list *bl, const char *talkie);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_talkiebox_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_talkiebox_pre[hIndex].func;
+			preHookFunc(bl, talkie);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.talkiebox(bl, talkie);
+	}
+	if( HPMHooks.count.HP_clif_talkiebox_post ) {
+		void (*postHookFunc) (struct block_list *bl, const char *talkie);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_talkiebox_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_talkiebox_post[hIndex].func;
+			postHookFunc(bl, talkie);
+		}
+	}
+	return;
+}
+void HP_clif_wedding_effect(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_wedding_effect_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wedding_effect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_wedding_effect_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.wedding_effect(bl);
+	}
+	if( HPMHooks.count.HP_clif_wedding_effect_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wedding_effect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_wedding_effect_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_divorced(struct map_session_data *sd, const char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_divorced_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_divorced_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_divorced_pre[hIndex].func;
+			preHookFunc(sd, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.divorced(sd, name);
+	}
+	if( HPMHooks.count.HP_clif_divorced_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_divorced_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_divorced_post[hIndex].func;
+			postHookFunc(sd, name);
+		}
+	}
+	return;
+}
+void HP_clif_callpartner(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_callpartner_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_callpartner_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_callpartner_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.callpartner(sd);
+	}
+	if( HPMHooks.count.HP_clif_callpartner_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_callpartner_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_callpartner_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_clif_skill_damage(struct block_list *src, struct block_list *dst, unsigned int tick, int sdelay, int ddelay, int64 damage, int div, uint16 skill_id, uint16 skill_lv, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_skill_damage_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *dst, unsigned int *tick, int *sdelay, int *ddelay, int64 *damage, int *div, uint16 *skill_id, uint16 *skill_lv, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, dst, &tick, &sdelay, &ddelay, &damage, &div, &skill_id, &skill_lv, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.skill_damage(src, dst, tick, sdelay, ddelay, damage, div, skill_id, skill_lv, type);
+	}
+	if( HPMHooks.count.HP_clif_skill_damage_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, unsigned int *tick, int *sdelay, int *ddelay, int64 *damage, int *div, uint16 *skill_id, uint16 *skill_lv, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, dst, &tick, &sdelay, &ddelay, &damage, &div, &skill_id, &skill_lv, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_clif_skill_nodamage(struct block_list *src, struct block_list *dst, uint16 skill_id, int heal, int fail) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_skill_nodamage_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *dst, uint16 *skill_id, int *heal, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_nodamage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_nodamage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, dst, &skill_id, &heal, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.skill_nodamage(src, dst, skill_id, heal, fail);
+	}
+	if( HPMHooks.count.HP_clif_skill_nodamage_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, uint16 *skill_id, int *heal, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_nodamage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_nodamage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, dst, &skill_id, &heal, &fail);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_skill_poseffect(struct block_list *src, uint16 skill_id, int val, int x, int y, int tick) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_poseffect_pre ) {
+		void (*preHookFunc) (struct block_list *src, uint16 *skill_id, int *val, int *x, int *y, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_poseffect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_poseffect_pre[hIndex].func;
+			preHookFunc(src, &skill_id, &val, &x, &y, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_poseffect(src, skill_id, val, x, y, tick);
+	}
+	if( HPMHooks.count.HP_clif_skill_poseffect_post ) {
+		void (*postHookFunc) (struct block_list *src, uint16 *skill_id, int *val, int *x, int *y, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_poseffect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_poseffect_post[hIndex].func;
+			postHookFunc(src, &skill_id, &val, &x, &y, &tick);
+		}
+	}
+	return;
+}
+void HP_clif_skill_estimation(struct map_session_data *sd, struct block_list *dst) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_estimation_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct block_list *dst);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_estimation_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_estimation_pre[hIndex].func;
+			preHookFunc(sd, dst);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_estimation(sd, dst);
+	}
+	if( HPMHooks.count.HP_clif_skill_estimation_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct block_list *dst);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_estimation_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_estimation_post[hIndex].func;
+			postHookFunc(sd, dst);
+		}
+	}
+	return;
+}
+void HP_clif_skill_warppoint(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, unsigned short map1, unsigned short map2, unsigned short map3, unsigned short map4) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skill_warppoint_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, unsigned short *map1, unsigned short *map2, unsigned short *map3, unsigned short *map4);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_warppoint_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skill_warppoint_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &skill_lv, &map1, &map2, &map3, &map4);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skill_warppoint(sd, skill_id, skill_lv, map1, map2, map3, map4);
+	}
+	if( HPMHooks.count.HP_clif_skill_warppoint_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, unsigned short *map1, unsigned short *map2, unsigned short *map3, unsigned short *map4);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_warppoint_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skill_warppoint_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &skill_lv, &map1, &map2, &map3, &map4);
+		}
+	}
+	return;
+}
+void HP_clif_skillcasting(struct block_list *bl, int src_id, int dst_id, int dst_x, int dst_y, uint16 skill_id, int property, int casttime) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skillcasting_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *src_id, int *dst_id, int *dst_x, int *dst_y, uint16 *skill_id, int *property, int *casttime);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcasting_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skillcasting_pre[hIndex].func;
+			preHookFunc(bl, &src_id, &dst_id, &dst_x, &dst_y, &skill_id, &property, &casttime);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skillcasting(bl, src_id, dst_id, dst_x, dst_y, skill_id, property, casttime);
+	}
+	if( HPMHooks.count.HP_clif_skillcasting_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *src_id, int *dst_id, int *dst_x, int *dst_y, uint16 *skill_id, int *property, int *casttime);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcasting_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skillcasting_post[hIndex].func;
+			postHookFunc(bl, &src_id, &dst_id, &dst_x, &dst_y, &skill_id, &property, &casttime);
+		}
+	}
+	return;
+}
+void HP_clif_produce_effect(struct map_session_data *sd, int flag, int nameid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_produce_effect_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_produce_effect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_produce_effect_pre[hIndex].func;
+			preHookFunc(sd, &flag, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.produce_effect(sd, flag, nameid);
+	}
+	if( HPMHooks.count.HP_clif_produce_effect_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_produce_effect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_produce_effect_post[hIndex].func;
+			postHookFunc(sd, &flag, &nameid);
+		}
+	}
+	return;
+}
+void HP_clif_devotion(struct block_list *src, struct map_session_data *tsd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_devotion_pre ) {
+		void (*preHookFunc) (struct block_list *src, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_devotion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_devotion_pre[hIndex].func;
+			preHookFunc(src, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.devotion(src, tsd);
+	}
+	if( HPMHooks.count.HP_clif_devotion_post ) {
+		void (*postHookFunc) (struct block_list *src, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_devotion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_devotion_post[hIndex].func;
+			postHookFunc(src, tsd);
+		}
+	}
+	return;
+}
+void HP_clif_spiritball(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_spiritball_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_spiritball_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.spiritball(bl);
+	}
+	if( HPMHooks.count.HP_clif_spiritball_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_spiritball_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_spiritball_single(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_spiritball_single_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_spiritball_single_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.spiritball_single(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_spiritball_single_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_spiritball_single_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_bladestop(struct block_list *src, int dst_id, int active) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bladestop_pre ) {
+		void (*preHookFunc) (struct block_list *src, int *dst_id, int *active);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bladestop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bladestop_pre[hIndex].func;
+			preHookFunc(src, &dst_id, &active);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bladestop(src, dst_id, active);
+	}
+	if( HPMHooks.count.HP_clif_bladestop_post ) {
+		void (*postHookFunc) (struct block_list *src, int *dst_id, int *active);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bladestop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bladestop_post[hIndex].func;
+			postHookFunc(src, &dst_id, &active);
+		}
+	}
+	return;
+}
+void HP_clif_mvp_effect(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mvp_effect_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_effect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mvp_effect_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mvp_effect(sd);
+	}
+	if( HPMHooks.count.HP_clif_mvp_effect_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_effect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mvp_effect_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_heal(int fd, int type, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_heal_pre ) {
+		void (*preHookFunc) (int *fd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_heal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_heal_pre[hIndex].func;
+			preHookFunc(&fd, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.heal(fd, type, val);
+	}
+	if( HPMHooks.count.HP_clif_heal_post ) {
+		void (*postHookFunc) (int *fd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_heal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_heal_post[hIndex].func;
+			postHookFunc(&fd, &type, &val);
+		}
+	}
+	return;
+}
+void HP_clif_resurrection(struct block_list *bl, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_resurrection_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_resurrection_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_resurrection_pre[hIndex].func;
+			preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.resurrection(bl, type);
+	}
+	if( HPMHooks.count.HP_clif_resurrection_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_resurrection_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_resurrection_post[hIndex].func;
+			postHookFunc(bl, &type);
+		}
+	}
+	return;
+}
+void HP_clif_refine(int fd, int fail, int index, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_refine_pre ) {
+		void (*preHookFunc) (int *fd, int *fail, int *index, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refine_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_refine_pre[hIndex].func;
+			preHookFunc(&fd, &fail, &index, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.refine(fd, fail, index, val);
+	}
+	if( HPMHooks.count.HP_clif_refine_post ) {
+		void (*postHookFunc) (int *fd, int *fail, int *index, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refine_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_refine_post[hIndex].func;
+			postHookFunc(&fd, &fail, &index, &val);
+		}
+	}
+	return;
+}
+void HP_clif_weather(int16 m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_weather_pre ) {
+		void (*preHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_weather_pre[hIndex].func;
+			preHookFunc(&m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.weather(m);
+	}
+	if( HPMHooks.count.HP_clif_weather_post ) {
+		void (*postHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_weather_post[hIndex].func;
+			postHookFunc(&m);
+		}
+	}
+	return;
+}
+void HP_clif_specialeffect(struct block_list *bl, int type, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_specialeffect_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *type, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_specialeffect_pre[hIndex].func;
+			preHookFunc(bl, &type, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.specialeffect(bl, type, target);
+	}
+	if( HPMHooks.count.HP_clif_specialeffect_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *type, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_specialeffect_post[hIndex].func;
+			postHookFunc(bl, &type, &target);
+		}
+	}
+	return;
+}
+void HP_clif_specialeffect_single(struct block_list *bl, int type, int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_specialeffect_single_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *type, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_specialeffect_single_pre[hIndex].func;
+			preHookFunc(bl, &type, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.specialeffect_single(bl, type, fd);
+	}
+	if( HPMHooks.count.HP_clif_specialeffect_single_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *type, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_specialeffect_single_post[hIndex].func;
+			postHookFunc(bl, &type, &fd);
+		}
+	}
+	return;
+}
+void HP_clif_specialeffect_value(struct block_list *bl, int effect_id, int num, send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_specialeffect_value_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *effect_id, int *num, send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_value_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_specialeffect_value_pre[hIndex].func;
+			preHookFunc(bl, &effect_id, &num, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.specialeffect_value(bl, effect_id, num, target);
+	}
+	if( HPMHooks.count.HP_clif_specialeffect_value_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *effect_id, int *num, send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_value_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_specialeffect_value_post[hIndex].func;
+			postHookFunc(bl, &effect_id, &num, &target);
+		}
+	}
+	return;
+}
+void HP_clif_millenniumshield(struct map_session_data *sd, short shields) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_millenniumshield_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *shields);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_millenniumshield_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_millenniumshield_pre[hIndex].func;
+			preHookFunc(sd, &shields);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.millenniumshield(sd, shields);
+	}
+	if( HPMHooks.count.HP_clif_millenniumshield_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *shields);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_millenniumshield_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_millenniumshield_post[hIndex].func;
+			postHookFunc(sd, &shields);
+		}
+	}
+	return;
+}
+void HP_clif_charm(struct map_session_data *sd, short type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_charm_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charm_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_charm_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.charm(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_charm_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charm_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_charm_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_charm_single(int fd, struct map_session_data *sd, short type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_charm_single_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd, short *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charm_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_charm_single_pre[hIndex].func;
+			preHookFunc(&fd, sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.charm_single(fd, sd, type);
+	}
+	if( HPMHooks.count.HP_clif_charm_single_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd, short *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charm_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_charm_single_post[hIndex].func;
+			postHookFunc(&fd, sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_snap(struct block_list *bl, short x, short y) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_snap_pre ) {
+		void (*preHookFunc) (struct block_list *bl, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_snap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_snap_pre[hIndex].func;
+			preHookFunc(bl, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.snap(bl, x, y);
+	}
+	if( HPMHooks.count.HP_clif_snap_post ) {
+		void (*postHookFunc) (struct block_list *bl, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_snap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_snap_post[hIndex].func;
+			postHookFunc(bl, &x, &y);
+		}
+	}
+	return;
+}
+void HP_clif_weather_check(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_weather_check_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_weather_check_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.weather_check(sd);
+	}
+	if( HPMHooks.count.HP_clif_weather_check_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_weather_check_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_playBGM(struct map_session_data *sd, const char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_playBGM_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_playBGM_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_playBGM_pre[hIndex].func;
+			preHookFunc(sd, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.playBGM(sd, name);
+	}
+	if( HPMHooks.count.HP_clif_playBGM_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_playBGM_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_playBGM_post[hIndex].func;
+			postHookFunc(sd, name);
+		}
+	}
+	return;
+}
+void HP_clif_soundeffect(struct map_session_data *sd, struct block_list *bl, const char *name, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_soundeffect_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, const char *name, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_soundeffect_pre[hIndex].func;
+			preHookFunc(sd, bl, name, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.soundeffect(sd, bl, name, type);
+	}
+	if( HPMHooks.count.HP_clif_soundeffect_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl, const char *name, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_soundeffect_post[hIndex].func;
+			postHookFunc(sd, bl, name, &type);
+		}
+	}
+	return;
+}
+void HP_clif_soundeffectall(struct block_list *bl, const char *name, int type, enum send_target coverage) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_soundeffectall_pre ) {
+		void (*preHookFunc) (struct block_list *bl, const char *name, int *type, enum send_target *coverage);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffectall_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_soundeffectall_pre[hIndex].func;
+			preHookFunc(bl, name, &type, &coverage);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.soundeffectall(bl, name, type, coverage);
+	}
+	if( HPMHooks.count.HP_clif_soundeffectall_post ) {
+		void (*postHookFunc) (struct block_list *bl, const char *name, int *type, enum send_target *coverage);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffectall_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_soundeffectall_post[hIndex].func;
+			postHookFunc(bl, name, &type, &coverage);
+		}
+	}
+	return;
+}
+void HP_clif_GlobalMessage(struct block_list *bl, const char *message) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_GlobalMessage_pre ) {
+		void (*preHookFunc) (struct block_list *bl, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GlobalMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_GlobalMessage_pre[hIndex].func;
+			preHookFunc(bl, message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.GlobalMessage(bl, message);
+	}
+	if( HPMHooks.count.HP_clif_GlobalMessage_post ) {
+		void (*postHookFunc) (struct block_list *bl, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GlobalMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_GlobalMessage_post[hIndex].func;
+			postHookFunc(bl, message);
+		}
+	}
+	return;
+}
+void HP_clif_createchat(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_createchat_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_createchat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_createchat_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.createchat(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_createchat_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_createchat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_createchat_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_dispchat(struct chat_data *cd, int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_dispchat_pre ) {
+		void (*preHookFunc) (struct chat_data *cd, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dispchat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_dispchat_pre[hIndex].func;
+			preHookFunc(cd, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.dispchat(cd, fd);
+	}
+	if( HPMHooks.count.HP_clif_dispchat_post ) {
+		void (*postHookFunc) (struct chat_data *cd, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dispchat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_dispchat_post[hIndex].func;
+			postHookFunc(cd, &fd);
+		}
+	}
+	return;
+}
+void HP_clif_joinchatfail(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_joinchatfail_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatfail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_joinchatfail_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.joinchatfail(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_joinchatfail_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatfail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_joinchatfail_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_joinchatok(struct map_session_data *sd, struct chat_data *cd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_joinchatok_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_joinchatok_pre[hIndex].func;
+			preHookFunc(sd, cd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.joinchatok(sd, cd);
+	}
+	if( HPMHooks.count.HP_clif_joinchatok_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_joinchatok_post[hIndex].func;
+			postHookFunc(sd, cd);
+		}
+	}
+	return;
+}
+void HP_clif_addchat(struct chat_data *cd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_addchat_pre ) {
+		void (*preHookFunc) (struct chat_data *cd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addchat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_addchat_pre[hIndex].func;
+			preHookFunc(cd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.addchat(cd, sd);
+	}
+	if( HPMHooks.count.HP_clif_addchat_post ) {
+		void (*postHookFunc) (struct chat_data *cd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addchat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_addchat_post[hIndex].func;
+			postHookFunc(cd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_changechatowner(struct chat_data *cd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changechatowner_pre ) {
+		void (*preHookFunc) (struct chat_data *cd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatowner_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changechatowner_pre[hIndex].func;
+			preHookFunc(cd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changechatowner(cd, sd);
+	}
+	if( HPMHooks.count.HP_clif_changechatowner_post ) {
+		void (*postHookFunc) (struct chat_data *cd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatowner_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changechatowner_post[hIndex].func;
+			postHookFunc(cd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_clearchat(struct chat_data *cd, int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_clearchat_pre ) {
+		void (*preHookFunc) (struct chat_data *cd, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_clearchat_pre[hIndex].func;
+			preHookFunc(cd, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.clearchat(cd, fd);
+	}
+	if( HPMHooks.count.HP_clif_clearchat_post ) {
+		void (*postHookFunc) (struct chat_data *cd, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_clearchat_post[hIndex].func;
+			postHookFunc(cd, &fd);
+		}
+	}
+	return;
+}
+void HP_clif_leavechat(struct chat_data *cd, struct map_session_data *sd, bool flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_leavechat_pre ) {
+		void (*preHookFunc) (struct chat_data *cd, struct map_session_data *sd, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_leavechat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_leavechat_pre[hIndex].func;
+			preHookFunc(cd, sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.leavechat(cd, sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_leavechat_post ) {
+		void (*postHookFunc) (struct chat_data *cd, struct map_session_data *sd, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_leavechat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_leavechat_post[hIndex].func;
+			postHookFunc(cd, sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_changechatstatus(struct chat_data *cd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_changechatstatus_pre ) {
+		void (*preHookFunc) (struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatstatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_changechatstatus_pre[hIndex].func;
+			preHookFunc(cd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.changechatstatus(cd);
+	}
+	if( HPMHooks.count.HP_clif_changechatstatus_post ) {
+		void (*postHookFunc) (struct chat_data *cd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatstatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_changechatstatus_post[hIndex].func;
+			postHookFunc(cd);
+		}
+	}
+	return;
+}
+void HP_clif_wis_message(int fd, const char *nick, const char *mes, int mes_len) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_wis_message_pre ) {
+		void (*preHookFunc) (int *fd, const char *nick, const char *mes, int *mes_len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_wis_message_pre[hIndex].func;
+			preHookFunc(&fd, nick, mes, &mes_len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.wis_message(fd, nick, mes, mes_len);
+	}
+	if( HPMHooks.count.HP_clif_wis_message_post ) {
+		void (*postHookFunc) (int *fd, const char *nick, const char *mes, int *mes_len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_wis_message_post[hIndex].func;
+			postHookFunc(&fd, nick, mes, &mes_len);
+		}
+	}
+	return;
+}
+void HP_clif_wis_end(int fd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_wis_end_pre ) {
+		void (*preHookFunc) (int *fd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_wis_end_pre[hIndex].func;
+			preHookFunc(&fd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.wis_end(fd, flag);
+	}
+	if( HPMHooks.count.HP_clif_wis_end_post ) {
+		void (*postHookFunc) (int *fd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_wis_end_post[hIndex].func;
+			postHookFunc(&fd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_disp_onlyself(struct map_session_data *sd, const char *mes, int len) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_disp_onlyself_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_onlyself_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_disp_onlyself_pre[hIndex].func;
+			preHookFunc(sd, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.disp_onlyself(sd, mes, len);
+	}
+	if( HPMHooks.count.HP_clif_disp_onlyself_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_onlyself_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_disp_onlyself_post[hIndex].func;
+			postHookFunc(sd, mes, &len);
+		}
+	}
+	return;
+}
+void HP_clif_disp_message(struct block_list *src, const char *mes, int len, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_disp_message_pre ) {
+		void (*preHookFunc) (struct block_list *src, const char *mes, int *len, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_disp_message_pre[hIndex].func;
+			preHookFunc(src, mes, &len, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.disp_message(src, mes, len, target);
+	}
+	if( HPMHooks.count.HP_clif_disp_message_post ) {
+		void (*postHookFunc) (struct block_list *src, const char *mes, int *len, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_disp_message_post[hIndex].func;
+			postHookFunc(src, mes, &len, &target);
+		}
+	}
+	return;
+}
+void HP_clif_broadcast(struct block_list *bl, const char *mes, int len, int type, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_broadcast_pre ) {
+		void (*preHookFunc) (struct block_list *bl, const char *mes, int *len, int *type, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_broadcast_pre[hIndex].func;
+			preHookFunc(bl, mes, &len, &type, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.broadcast(bl, mes, len, type, target);
+	}
+	if( HPMHooks.count.HP_clif_broadcast_post ) {
+		void (*postHookFunc) (struct block_list *bl, const char *mes, int *len, int *type, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_broadcast_post[hIndex].func;
+			postHookFunc(bl, mes, &len, &type, &target);
+		}
+	}
+	return;
+}
+void HP_clif_broadcast2(struct block_list *bl, const char *mes, int len, unsigned long fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_broadcast2_pre ) {
+		void (*preHookFunc) (struct block_list *bl, const char *mes, int *len, unsigned long *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_broadcast2_pre[hIndex].func;
+			preHookFunc(bl, mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.broadcast2(bl, mes, len, fontColor, fontType, fontSize, fontAlign, fontY, target);
+	}
+	if( HPMHooks.count.HP_clif_broadcast2_post ) {
+		void (*postHookFunc) (struct block_list *bl, const char *mes, int *len, unsigned long *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_broadcast2_post[hIndex].func;
+			postHookFunc(bl, mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY, &target);
+		}
+	}
+	return;
+}
+void HP_clif_messagecolor(struct block_list *bl, unsigned long color, const char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_messagecolor_pre ) {
+		void (*preHookFunc) (struct block_list *bl, unsigned long *color, const char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_messagecolor_pre[hIndex].func;
+			preHookFunc(bl, &color, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.messagecolor(bl, color, msg);
+	}
+	if( HPMHooks.count.HP_clif_messagecolor_post ) {
+		void (*postHookFunc) (struct block_list *bl, unsigned long *color, const char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_messagecolor_post[hIndex].func;
+			postHookFunc(bl, &color, msg);
+		}
+	}
+	return;
+}
+void HP_clif_disp_overhead(struct block_list *bl, const char *mes) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_disp_overhead_pre ) {
+		void (*preHookFunc) (struct block_list *bl, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_overhead_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_disp_overhead_pre[hIndex].func;
+			preHookFunc(bl, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.disp_overhead(bl, mes);
+	}
+	if( HPMHooks.count.HP_clif_disp_overhead_post ) {
+		void (*postHookFunc) (struct block_list *bl, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_overhead_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_disp_overhead_post[hIndex].func;
+			postHookFunc(bl, mes);
+		}
+	}
+	return;
+}
+void HP_clif_msg(struct map_session_data *sd, unsigned short id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_msg_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_msg_pre[hIndex].func;
+			preHookFunc(sd, &id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.msg(sd, id);
+	}
+	if( HPMHooks.count.HP_clif_msg_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_msg_post[hIndex].func;
+			postHookFunc(sd, &id);
+		}
+	}
+	return;
+}
+void HP_clif_msg_value(struct map_session_data *sd, unsigned short id, int value) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_msg_value_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *id, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msg_value_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_msg_value_pre[hIndex].func;
+			preHookFunc(sd, &id, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.msg_value(sd, id, value);
+	}
+	if( HPMHooks.count.HP_clif_msg_value_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *id, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msg_value_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_msg_value_post[hIndex].func;
+			postHookFunc(sd, &id, &value);
+		}
+	}
+	return;
+}
+void HP_clif_msg_skill(struct map_session_data *sd, uint16 skill_id, int msg_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_msg_skill_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *msg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msg_skill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_msg_skill_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &msg_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.msg_skill(sd, skill_id, msg_id);
+	}
+	if( HPMHooks.count.HP_clif_msg_skill_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *msg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msg_skill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_msg_skill_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &msg_id);
+		}
+	}
+	return;
+}
+void HP_clif_msgtable(int fd, int line) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_msgtable_pre ) {
+		void (*preHookFunc) (int *fd, int *line);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_msgtable_pre[hIndex].func;
+			preHookFunc(&fd, &line);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.msgtable(fd, line);
+	}
+	if( HPMHooks.count.HP_clif_msgtable_post ) {
+		void (*postHookFunc) (int *fd, int *line);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_msgtable_post[hIndex].func;
+			postHookFunc(&fd, &line);
+		}
+	}
+	return;
+}
+void HP_clif_msgtable_num(int fd, int line, int num) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_msgtable_num_pre ) {
+		void (*preHookFunc) (int *fd, int *line, int *num);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_num_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_msgtable_num_pre[hIndex].func;
+			preHookFunc(&fd, &line, &num);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.msgtable_num(fd, line, num);
+	}
+	if( HPMHooks.count.HP_clif_msgtable_num_post ) {
+		void (*postHookFunc) (int *fd, int *line, int *num);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_num_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_msgtable_num_post[hIndex].func;
+			postHookFunc(&fd, &line, &num);
+		}
+	}
+	return;
+}
+void HP_clif_message(const int fd, const char *mes) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_message_pre ) {
+		void (*preHookFunc) (const int *fd, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_message_pre[hIndex].func;
+			preHookFunc(&fd, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.message(fd, mes);
+	}
+	if( HPMHooks.count.HP_clif_message_post ) {
+		void (*postHookFunc) (const int *fd, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_message_post[hIndex].func;
+			postHookFunc(&fd, mes);
+		}
+	}
+	return;
+}
+void HP_clif_messageln(const int fd, const char *mes) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_messageln_pre ) {
+		void (*preHookFunc) (const int *fd, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messageln_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_messageln_pre[hIndex].func;
+			preHookFunc(&fd, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.messageln(fd, mes);
+	}
+	if( HPMHooks.count.HP_clif_messageln_post ) {
+		void (*postHookFunc) (const int *fd, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messageln_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_messageln_post[hIndex].func;
+			postHookFunc(&fd, mes);
+		}
+	}
+	return;
+}
+int HP_clif_colormes(int fd, enum clif_colors color, const char *msg) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_colormes_pre ) {
+		int (*preHookFunc) (int *fd, enum clif_colors *color, const char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_colormes_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_colormes_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd, &color, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.colormes(fd, color, msg);
+	}
+	if( HPMHooks.count.HP_clif_colormes_post ) {
+		int (*postHookFunc) (int retVal___, int *fd, enum clif_colors *color, const char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_colormes_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_colormes_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd, &color, msg);
+		}
+	}
+	return retVal___;
+}
+bool HP_clif_process_message(struct map_session_data *sd, int format, char **name_, int *namelen_, char **message_, int *messagelen_) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_clif_process_message_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, int *format, char **name_, int *namelen_, char **message_, int *messagelen_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_process_message_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &format, name_, namelen_, message_, messagelen_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.process_message(sd, format, name_, namelen_, message_, messagelen_);
+	}
+	if( HPMHooks.count.HP_clif_process_message_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *format, char **name_, int *namelen_, char **message_, int *messagelen_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_process_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &format, name_, namelen_, message_, messagelen_);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_wisexin(struct map_session_data *sd, int type, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_wisexin_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisexin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_wisexin_pre[hIndex].func;
+			preHookFunc(sd, &type, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.wisexin(sd, type, flag);
+	}
+	if( HPMHooks.count.HP_clif_wisexin_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisexin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_wisexin_post[hIndex].func;
+			postHookFunc(sd, &type, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_wisall(struct map_session_data *sd, int type, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_wisall_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisall_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_wisall_pre[hIndex].func;
+			preHookFunc(sd, &type, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.wisall(sd, type, flag);
+	}
+	if( HPMHooks.count.HP_clif_wisall_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisall_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_wisall_post[hIndex].func;
+			postHookFunc(sd, &type, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_PMIgnoreList(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PMIgnoreList_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PMIgnoreList_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PMIgnoreList_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PMIgnoreList(sd);
+	}
+	if( HPMHooks.count.HP_clif_PMIgnoreList_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PMIgnoreList_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PMIgnoreList_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_traderequest(struct map_session_data *sd, const char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_traderequest_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_traderequest_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_traderequest_pre[hIndex].func;
+			preHookFunc(sd, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.traderequest(sd, name);
+	}
+	if( HPMHooks.count.HP_clif_traderequest_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_traderequest_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_traderequest_post[hIndex].func;
+			postHookFunc(sd, name);
+		}
+	}
+	return;
+}
+void HP_clif_tradestart(struct map_session_data *sd, uint8 type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_tradestart_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint8 *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradestart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_tradestart_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.tradestart(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_tradestart_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint8 *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradestart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_tradestart_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_tradeadditem(struct map_session_data *sd, struct map_session_data *tsd, int index, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_tradeadditem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeadditem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_tradeadditem_pre[hIndex].func;
+			preHookFunc(sd, tsd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.tradeadditem(sd, tsd, index, amount);
+	}
+	if( HPMHooks.count.HP_clif_tradeadditem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeadditem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_tradeadditem_post[hIndex].func;
+			postHookFunc(sd, tsd, &index, &amount);
+		}
+	}
+	return;
+}
+void HP_clif_tradeitemok(struct map_session_data *sd, int index, int fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_tradeitemok_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *index, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeitemok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_tradeitemok_pre[hIndex].func;
+			preHookFunc(sd, &index, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.tradeitemok(sd, index, fail);
+	}
+	if( HPMHooks.count.HP_clif_tradeitemok_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *index, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeitemok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_tradeitemok_post[hIndex].func;
+			postHookFunc(sd, &index, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_tradedeal_lock(struct map_session_data *sd, int fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_tradedeal_lock_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradedeal_lock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_tradedeal_lock_pre[hIndex].func;
+			preHookFunc(sd, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.tradedeal_lock(sd, fail);
+	}
+	if( HPMHooks.count.HP_clif_tradedeal_lock_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradedeal_lock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_tradedeal_lock_post[hIndex].func;
+			postHookFunc(sd, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_tradecancelled(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_tradecancelled_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecancelled_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_tradecancelled_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.tradecancelled(sd);
+	}
+	if( HPMHooks.count.HP_clif_tradecancelled_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecancelled_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_tradecancelled_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_tradecompleted(struct map_session_data *sd, int fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_tradecompleted_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecompleted_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_tradecompleted_pre[hIndex].func;
+			preHookFunc(sd, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.tradecompleted(sd, fail);
+	}
+	if( HPMHooks.count.HP_clif_tradecompleted_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecompleted_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_tradecompleted_post[hIndex].func;
+			postHookFunc(sd, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_tradeundo(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_tradeundo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeundo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_tradeundo_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.tradeundo(sd);
+	}
+	if( HPMHooks.count.HP_clif_tradeundo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeundo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_tradeundo_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_openvendingreq(struct map_session_data *sd, int num) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_openvendingreq_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *num);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvendingreq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_openvendingreq_pre[hIndex].func;
+			preHookFunc(sd, &num);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.openvendingreq(sd, num);
+	}
+	if( HPMHooks.count.HP_clif_openvendingreq_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *num);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvendingreq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_openvendingreq_post[hIndex].func;
+			postHookFunc(sd, &num);
+		}
+	}
+	return;
+}
+void HP_clif_showvendingboard(struct block_list *bl, const char *message, int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_showvendingboard_pre ) {
+		void (*preHookFunc) (struct block_list *bl, const char *message, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showvendingboard_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_showvendingboard_pre[hIndex].func;
+			preHookFunc(bl, message, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.showvendingboard(bl, message, fd);
+	}
+	if( HPMHooks.count.HP_clif_showvendingboard_post ) {
+		void (*postHookFunc) (struct block_list *bl, const char *message, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showvendingboard_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_showvendingboard_post[hIndex].func;
+			postHookFunc(bl, message, &fd);
+		}
+	}
+	return;
+}
+void HP_clif_closevendingboard(struct block_list *bl, int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_closevendingboard_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_closevendingboard_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_closevendingboard_pre[hIndex].func;
+			preHookFunc(bl, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.closevendingboard(bl, fd);
+	}
+	if( HPMHooks.count.HP_clif_closevendingboard_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_closevendingboard_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_closevendingboard_post[hIndex].func;
+			postHookFunc(bl, &fd);
+		}
+	}
+	return;
+}
+void HP_clif_vendinglist(struct map_session_data *sd, unsigned int id, struct s_vending *vending_list) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_vendinglist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *id, struct s_vending *vending_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendinglist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_vendinglist_pre[hIndex].func;
+			preHookFunc(sd, &id, vending_list);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.vendinglist(sd, id, vending_list);
+	}
+	if( HPMHooks.count.HP_clif_vendinglist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *id, struct s_vending *vending_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendinglist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_vendinglist_post[hIndex].func;
+			postHookFunc(sd, &id, vending_list);
+		}
+	}
+	return;
+}
+void HP_clif_buyvending(struct map_session_data *sd, int index, int amount, int fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyvending_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyvending_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyvending_pre[hIndex].func;
+			preHookFunc(sd, &index, &amount, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyvending(sd, index, amount, fail);
+	}
+	if( HPMHooks.count.HP_clif_buyvending_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *index, int *amount, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyvending_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyvending_post[hIndex].func;
+			postHookFunc(sd, &index, &amount, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_openvending(struct map_session_data *sd, int id, struct s_vending *vending_list) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_openvending_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *id, struct s_vending *vending_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvending_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_openvending_pre[hIndex].func;
+			preHookFunc(sd, &id, vending_list);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.openvending(sd, id, vending_list);
+	}
+	if( HPMHooks.count.HP_clif_openvending_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *id, struct s_vending *vending_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvending_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_openvending_post[hIndex].func;
+			postHookFunc(sd, &id, vending_list);
+		}
+	}
+	return;
+}
+void HP_clif_vendingreport(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_vendingreport_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendingreport_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_vendingreport_pre[hIndex].func;
+			preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.vendingreport(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_clif_vendingreport_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendingreport_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_vendingreport_post[hIndex].func;
+			postHookFunc(sd, &index, &amount);
+		}
+	}
+	return;
+}
+void HP_clif_storagelist(struct map_session_data *sd, struct item *items, int items_length) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_storagelist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct item *items, int *items_length);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storagelist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_storagelist_pre[hIndex].func;
+			preHookFunc(sd, items, &items_length);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.storagelist(sd, items, items_length);
+	}
+	if( HPMHooks.count.HP_clif_storagelist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct item *items, int *items_length);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storagelist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_storagelist_post[hIndex].func;
+			postHookFunc(sd, items, &items_length);
+		}
+	}
+	return;
+}
+void HP_clif_updatestorageamount(struct map_session_data *sd, int amount, int max_amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_updatestorageamount_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *amount, int *max_amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestorageamount_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_updatestorageamount_pre[hIndex].func;
+			preHookFunc(sd, &amount, &max_amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.updatestorageamount(sd, amount, max_amount);
+	}
+	if( HPMHooks.count.HP_clif_updatestorageamount_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *amount, int *max_amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestorageamount_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_updatestorageamount_post[hIndex].func;
+			postHookFunc(sd, &amount, &max_amount);
+		}
+	}
+	return;
+}
+void HP_clif_storageitemadded(struct map_session_data *sd, struct item *i, int index, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_storageitemadded_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct item *i, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemadded_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_storageitemadded_pre[hIndex].func;
+			preHookFunc(sd, i, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.storageitemadded(sd, i, index, amount);
+	}
+	if( HPMHooks.count.HP_clif_storageitemadded_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct item *i, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemadded_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_storageitemadded_post[hIndex].func;
+			postHookFunc(sd, i, &index, &amount);
+		}
+	}
+	return;
+}
+void HP_clif_storageitemremoved(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_storageitemremoved_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemremoved_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_storageitemremoved_pre[hIndex].func;
+			preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.storageitemremoved(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_clif_storageitemremoved_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemremoved_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_storageitemremoved_post[hIndex].func;
+			postHookFunc(sd, &index, &amount);
+		}
+	}
+	return;
+}
+void HP_clif_storageclose(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_storageclose_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageclose_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_storageclose_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.storageclose(sd);
+	}
+	if( HPMHooks.count.HP_clif_storageclose_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageclose_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_storageclose_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_skillinfoblock(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skillinfoblock_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfoblock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skillinfoblock_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skillinfoblock(sd);
+	}
+	if( HPMHooks.count.HP_clif_skillinfoblock_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfoblock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skillinfoblock_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_skillup(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skillup_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skillup_pre[hIndex].func;
+			preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skillup(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_clif_skillup_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skillup_post[hIndex].func;
+			postHookFunc(sd, &skill_id);
+		}
+	}
+	return;
+}
+void HP_clif_skillinfo(struct map_session_data *sd, int skill_id, int inf) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_skillinfo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *skill_id, int *inf);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_skillinfo_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &inf);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.skillinfo(sd, skill_id, inf);
+	}
+	if( HPMHooks.count.HP_clif_skillinfo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *skill_id, int *inf);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_skillinfo_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &inf);
+		}
+	}
+	return;
+}
+void HP_clif_addskill(struct map_session_data *sd, int id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_addskill_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_addskill_pre[hIndex].func;
+			preHookFunc(sd, &id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.addskill(sd, id);
+	}
+	if( HPMHooks.count.HP_clif_addskill_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_addskill_post[hIndex].func;
+			postHookFunc(sd, &id);
+		}
+	}
+	return;
+}
+void HP_clif_deleteskill(struct map_session_data *sd, int id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_deleteskill_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_deleteskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_deleteskill_pre[hIndex].func;
+			preHookFunc(sd, &id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.deleteskill(sd, id);
+	}
+	if( HPMHooks.count.HP_clif_deleteskill_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_deleteskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_deleteskill_post[hIndex].func;
+			postHookFunc(sd, &id);
+		}
+	}
+	return;
+}
+void HP_clif_party_created(struct map_session_data *sd, int result) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_created_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_created_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_created_pre[hIndex].func;
+			preHookFunc(sd, &result);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_created(sd, result);
+	}
+	if( HPMHooks.count.HP_clif_party_created_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_created_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_created_post[hIndex].func;
+			postHookFunc(sd, &result);
+		}
+	}
+	return;
+}
+void HP_clif_party_member_info(struct party_data *p, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_member_info_pre ) {
+		void (*preHookFunc) (struct party_data *p, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_member_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_member_info_pre[hIndex].func;
+			preHookFunc(p, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_member_info(p, sd);
+	}
+	if( HPMHooks.count.HP_clif_party_member_info_post ) {
+		void (*postHookFunc) (struct party_data *p, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_member_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_member_info_post[hIndex].func;
+			postHookFunc(p, sd);
+		}
+	}
+	return;
+}
+void HP_clif_party_info(struct party_data *p, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_info_pre ) {
+		void (*preHookFunc) (struct party_data *p, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_info_pre[hIndex].func;
+			preHookFunc(p, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_info(p, sd);
+	}
+	if( HPMHooks.count.HP_clif_party_info_post ) {
+		void (*postHookFunc) (struct party_data *p, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_info_post[hIndex].func;
+			postHookFunc(p, sd);
+		}
+	}
+	return;
+}
+void HP_clif_party_invite(struct map_session_data *sd, struct map_session_data *tsd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_invite_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_invite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_invite_pre[hIndex].func;
+			preHookFunc(sd, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_invite(sd, tsd);
+	}
+	if( HPMHooks.count.HP_clif_party_invite_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_invite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_invite_post[hIndex].func;
+			postHookFunc(sd, tsd);
+		}
+	}
+	return;
+}
+void HP_clif_party_inviteack(struct map_session_data *sd, const char *nick, int result) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_inviteack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *nick, int *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_inviteack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_inviteack_pre[hIndex].func;
+			preHookFunc(sd, nick, &result);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_inviteack(sd, nick, result);
+	}
+	if( HPMHooks.count.HP_clif_party_inviteack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *nick, int *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_inviteack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_inviteack_post[hIndex].func;
+			postHookFunc(sd, nick, &result);
+		}
+	}
+	return;
+}
+void HP_clif_party_option(struct party_data *p, struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_option_pre ) {
+		void (*preHookFunc) (struct party_data *p, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_option_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_option_pre[hIndex].func;
+			preHookFunc(p, sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_option(p, sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_party_option_post ) {
+		void (*postHookFunc) (struct party_data *p, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_option_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_option_post[hIndex].func;
+			postHookFunc(p, sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_party_withdraw(struct party_data *p, struct map_session_data *sd, int account_id, const char *name, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_withdraw_pre ) {
+		void (*preHookFunc) (struct party_data *p, struct map_session_data *sd, int *account_id, const char *name, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_withdraw_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_withdraw_pre[hIndex].func;
+			preHookFunc(p, sd, &account_id, name, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_withdraw(p, sd, account_id, name, flag);
+	}
+	if( HPMHooks.count.HP_clif_party_withdraw_post ) {
+		void (*postHookFunc) (struct party_data *p, struct map_session_data *sd, int *account_id, const char *name, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_withdraw_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_withdraw_post[hIndex].func;
+			postHookFunc(p, sd, &account_id, name, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_party_message(struct party_data *p, int account_id, const char *mes, int len) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_message_pre ) {
+		void (*preHookFunc) (struct party_data *p, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_message_pre[hIndex].func;
+			preHookFunc(p, &account_id, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_message(p, account_id, mes, len);
+	}
+	if( HPMHooks.count.HP_clif_party_message_post ) {
+		void (*postHookFunc) (struct party_data *p, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_message_post[hIndex].func;
+			postHookFunc(p, &account_id, mes, &len);
+		}
+	}
+	return;
+}
+void HP_clif_party_xy(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_xy_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_xy_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_xy(sd);
+	}
+	if( HPMHooks.count.HP_clif_party_xy_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_xy_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_party_xy_single(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_xy_single_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_xy_single_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_xy_single(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_party_xy_single_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_xy_single_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_party_hp(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_hp_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_hp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_hp_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_hp(sd);
+	}
+	if( HPMHooks.count.HP_clif_party_hp_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_hp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_hp_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_party_xy_remove(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_xy_remove_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_xy_remove_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_xy_remove(sd);
+	}
+	if( HPMHooks.count.HP_clif_party_xy_remove_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_xy_remove_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_party_show_picker(struct map_session_data *sd, struct item *item_data) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_party_show_picker_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct item *item_data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_show_picker_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_party_show_picker_pre[hIndex].func;
+			preHookFunc(sd, item_data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.party_show_picker(sd, item_data);
+	}
+	if( HPMHooks.count.HP_clif_party_show_picker_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct item *item_data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_show_picker_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_party_show_picker_post[hIndex].func;
+			postHookFunc(sd, item_data);
+		}
+	}
+	return;
+}
+void HP_clif_partyinvitationstate(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_partyinvitationstate_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partyinvitationstate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_partyinvitationstate_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.partyinvitationstate(sd);
+	}
+	if( HPMHooks.count.HP_clif_partyinvitationstate_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partyinvitationstate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_partyinvitationstate_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_created(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_created_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_created_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_created_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_created(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_guild_created_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_created_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_created_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_guild_belonginfo(struct map_session_data *sd, struct guild *g) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_belonginfo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_belonginfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_belonginfo_pre[hIndex].func;
+			preHookFunc(sd, g);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_belonginfo(sd, g);
+	}
+	if( HPMHooks.count.HP_clif_guild_belonginfo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_belonginfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_belonginfo_post[hIndex].func;
+			postHookFunc(sd, g);
+		}
+	}
+	return;
+}
+void HP_clif_guild_masterormember(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_masterormember_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_masterormember_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_masterormember_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_masterormember(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_masterormember_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_masterormember_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_masterormember_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_basicinfo(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_basicinfo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_basicinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_basicinfo_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_basicinfo(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_basicinfo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_basicinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_basicinfo_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_allianceinfo(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_allianceinfo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_allianceinfo_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_allianceinfo(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_allianceinfo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_allianceinfo_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_memberlist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_memberlist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_memberlist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_memberlist(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_memberlist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_memberlist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_skillinfo(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_skillinfo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_skillinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_skillinfo_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_skillinfo(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_skillinfo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_skillinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_skillinfo_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_send_onlineinfo(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_send_onlineinfo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_send_onlineinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_send_onlineinfo_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_send_onlineinfo(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_send_onlineinfo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_send_onlineinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_send_onlineinfo_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_memberlogin_notice(struct guild *g, int idx, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_memberlogin_notice_pre ) {
+		void (*preHookFunc) (struct guild *g, int *idx, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlogin_notice_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_memberlogin_notice_pre[hIndex].func;
+			preHookFunc(g, &idx, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_memberlogin_notice(g, idx, flag);
+	}
+	if( HPMHooks.count.HP_clif_guild_memberlogin_notice_post ) {
+		void (*postHookFunc) (struct guild *g, int *idx, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlogin_notice_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_memberlogin_notice_post[hIndex].func;
+			postHookFunc(g, &idx, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_guild_invite(struct map_session_data *sd, struct guild *g) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_invite_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_invite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_invite_pre[hIndex].func;
+			preHookFunc(sd, g);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_invite(sd, g);
+	}
+	if( HPMHooks.count.HP_clif_guild_invite_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_invite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_invite_post[hIndex].func;
+			postHookFunc(sd, g);
+		}
+	}
+	return;
+}
+void HP_clif_guild_inviteack(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_inviteack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_inviteack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_inviteack_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_inviteack(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_guild_inviteack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_inviteack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_inviteack_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_guild_leave(struct map_session_data *sd, const char *name, const char *mes) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_leave_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *name, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_leave_pre[hIndex].func;
+			preHookFunc(sd, name, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_leave(sd, name, mes);
+	}
+	if( HPMHooks.count.HP_clif_guild_leave_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *name, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_leave_post[hIndex].func;
+			postHookFunc(sd, name, mes);
+		}
+	}
+	return;
+}
+void HP_clif_guild_expulsion(struct map_session_data *sd, const char *name, const char *mes, int account_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_expulsion_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *name, const char *mes, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_expulsion_pre[hIndex].func;
+			preHookFunc(sd, name, mes, &account_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_expulsion(sd, name, mes, account_id);
+	}
+	if( HPMHooks.count.HP_clif_guild_expulsion_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *name, const char *mes, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_expulsion_post[hIndex].func;
+			postHookFunc(sd, name, mes, &account_id);
+		}
+	}
+	return;
+}
+void HP_clif_guild_positionchanged(struct guild *g, int idx) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_positionchanged_pre ) {
+		void (*preHookFunc) (struct guild *g, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionchanged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_positionchanged_pre[hIndex].func;
+			preHookFunc(g, &idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_positionchanged(g, idx);
+	}
+	if( HPMHooks.count.HP_clif_guild_positionchanged_post ) {
+		void (*postHookFunc) (struct guild *g, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionchanged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_positionchanged_post[hIndex].func;
+			postHookFunc(g, &idx);
+		}
+	}
+	return;
+}
+void HP_clif_guild_memberpositionchanged(struct guild *g, int idx) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_memberpositionchanged_pre ) {
+		void (*preHookFunc) (struct guild *g, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberpositionchanged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_memberpositionchanged_pre[hIndex].func;
+			preHookFunc(g, &idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_memberpositionchanged(g, idx);
+	}
+	if( HPMHooks.count.HP_clif_guild_memberpositionchanged_post ) {
+		void (*postHookFunc) (struct guild *g, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberpositionchanged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_memberpositionchanged_post[hIndex].func;
+			postHookFunc(g, &idx);
+		}
+	}
+	return;
+}
+void HP_clif_guild_emblem(struct map_session_data *sd, struct guild *g) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_emblem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_emblem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_emblem_pre[hIndex].func;
+			preHookFunc(sd, g);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_emblem(sd, g);
+	}
+	if( HPMHooks.count.HP_clif_guild_emblem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_emblem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_emblem_post[hIndex].func;
+			postHookFunc(sd, g);
+		}
+	}
+	return;
+}
+void HP_clif_guild_emblem_area(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_emblem_area_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_emblem_area_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_emblem_area_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_emblem_area(bl);
+	}
+	if( HPMHooks.count.HP_clif_guild_emblem_area_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_emblem_area_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_emblem_area_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_clif_guild_notice(struct map_session_data *sd, struct guild *g) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_notice_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_notice_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_notice_pre[hIndex].func;
+			preHookFunc(sd, g);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_notice(sd, g);
+	}
+	if( HPMHooks.count.HP_clif_guild_notice_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_notice_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_notice_post[hIndex].func;
+			postHookFunc(sd, g);
+		}
+	}
+	return;
+}
+void HP_clif_guild_message(struct guild *g, int account_id, const char *mes, int len) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_message_pre ) {
+		void (*preHookFunc) (struct guild *g, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_message_pre[hIndex].func;
+			preHookFunc(g, &account_id, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_message(g, account_id, mes, len);
+	}
+	if( HPMHooks.count.HP_clif_guild_message_post ) {
+		void (*postHookFunc) (struct guild *g, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_message_post[hIndex].func;
+			postHookFunc(g, &account_id, mes, &len);
+		}
+	}
+	return;
+}
+int HP_clif_guild_skillup(struct map_session_data *sd, uint16 skill_id, int lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_guild_skillup_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_skillup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_skillup_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, &lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.guild_skillup(sd, skill_id, lv);
+	}
+	if( HPMHooks.count.HP_clif_guild_skillup_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_skillup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_skillup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, &lv);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_guild_reqalliance(struct map_session_data *sd, int account_id, const char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_reqalliance_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *account_id, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_reqalliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_reqalliance_pre[hIndex].func;
+			preHookFunc(sd, &account_id, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_reqalliance(sd, account_id, name);
+	}
+	if( HPMHooks.count.HP_clif_guild_reqalliance_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *account_id, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_reqalliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_reqalliance_post[hIndex].func;
+			postHookFunc(sd, &account_id, name);
+		}
+	}
+	return;
+}
+void HP_clif_guild_allianceack(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_allianceack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_allianceack_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_allianceack(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_guild_allianceack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_allianceack_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_guild_delalliance(struct map_session_data *sd, int guild_id, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_delalliance_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_delalliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_delalliance_pre[hIndex].func;
+			preHookFunc(sd, &guild_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_delalliance(sd, guild_id, flag);
+	}
+	if( HPMHooks.count.HP_clif_guild_delalliance_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_delalliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_delalliance_post[hIndex].func;
+			postHookFunc(sd, &guild_id, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_guild_oppositionack(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_oppositionack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_oppositionack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_oppositionack_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_oppositionack(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_guild_oppositionack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_oppositionack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_oppositionack_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_guild_broken(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_broken_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_broken_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_broken_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_broken(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_guild_broken_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_broken_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_broken_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_guild_xy(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_xy_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_xy_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_xy(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_xy_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_xy_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_xy_single(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_xy_single_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_xy_single_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_xy_single(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_xy_single_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_xy_single_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_xy_remove(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_xy_remove_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_xy_remove_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_xy_remove(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_xy_remove_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_xy_remove_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_positionnamelist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_positionnamelist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionnamelist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_positionnamelist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_positionnamelist(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_positionnamelist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionnamelist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_positionnamelist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_positioninfolist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_positioninfolist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positioninfolist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_positioninfolist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_positioninfolist(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_positioninfolist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positioninfolist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_positioninfolist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_guild_expulsionlist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_guild_expulsionlist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsionlist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_guild_expulsionlist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.guild_expulsionlist(sd);
+	}
+	if( HPMHooks.count.HP_clif_guild_expulsionlist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsionlist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_guild_expulsionlist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+bool HP_clif_validate_emblem(const uint8 *emblem, unsigned long emblem_len) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_clif_validate_emblem_pre ) {
+		bool (*preHookFunc) (const uint8 *emblem, unsigned long *emblem_len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_validate_emblem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_validate_emblem_pre[hIndex].func;
+			retVal___ = preHookFunc(emblem, &emblem_len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.validate_emblem(emblem, emblem_len);
+	}
+	if( HPMHooks.count.HP_clif_validate_emblem_post ) {
+		bool (*postHookFunc) (bool retVal___, const uint8 *emblem, unsigned long *emblem_len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_validate_emblem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_validate_emblem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, emblem, &emblem_len);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_bg_hp(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bg_hp_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_hp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bg_hp_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bg_hp(sd);
+	}
+	if( HPMHooks.count.HP_clif_bg_hp_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_hp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bg_hp_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_bg_xy(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bg_xy_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bg_xy_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bg_xy(sd);
+	}
+	if( HPMHooks.count.HP_clif_bg_xy_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bg_xy_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_bg_xy_remove(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bg_xy_remove_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bg_xy_remove_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bg_xy_remove(sd);
+	}
+	if( HPMHooks.count.HP_clif_bg_xy_remove_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bg_xy_remove_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_bg_message(struct battleground_data *bgd, int src_id, const char *name, const char *mes, int len) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bg_message_pre ) {
+		void (*preHookFunc) (struct battleground_data *bgd, int *src_id, const char *name, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bg_message_pre[hIndex].func;
+			preHookFunc(bgd, &src_id, name, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bg_message(bgd, src_id, name, mes, len);
+	}
+	if( HPMHooks.count.HP_clif_bg_message_post ) {
+		void (*postHookFunc) (struct battleground_data *bgd, int *src_id, const char *name, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bg_message_post[hIndex].func;
+			postHookFunc(bgd, &src_id, name, mes, &len);
+		}
+	}
+	return;
+}
+void HP_clif_bg_updatescore(int16 m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bg_updatescore_pre ) {
+		void (*preHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bg_updatescore_pre[hIndex].func;
+			preHookFunc(&m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bg_updatescore(m);
+	}
+	if( HPMHooks.count.HP_clif_bg_updatescore_post ) {
+		void (*postHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bg_updatescore_post[hIndex].func;
+			postHookFunc(&m);
+		}
+	}
+	return;
+}
+void HP_clif_bg_updatescore_single(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bg_updatescore_single_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bg_updatescore_single_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bg_updatescore_single(sd);
+	}
+	if( HPMHooks.count.HP_clif_bg_updatescore_single_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bg_updatescore_single_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_sendbgemblem_area(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_sendbgemblem_area_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_area_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_sendbgemblem_area_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.sendbgemblem_area(sd);
+	}
+	if( HPMHooks.count.HP_clif_sendbgemblem_area_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_area_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_sendbgemblem_area_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_sendbgemblem_single(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_sendbgemblem_single_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_sendbgemblem_single_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.sendbgemblem_single(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_sendbgemblem_single_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_sendbgemblem_single_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+int HP_clif_instance(int instance_id, int type, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_instance_pre ) {
+		int (*preHookFunc) (int *instance_id, int *type, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_instance_pre[hIndex].func;
+			retVal___ = preHookFunc(&instance_id, &type, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.instance(instance_id, type, flag);
+	}
+	if( HPMHooks.count.HP_clif_instance_post ) {
+		int (*postHookFunc) (int retVal___, int *instance_id, int *type, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_instance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &instance_id, &type, &flag);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_instance_join(int fd, int instance_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_instance_join_pre ) {
+		void (*preHookFunc) (int *fd, int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_join_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_instance_join_pre[hIndex].func;
+			preHookFunc(&fd, &instance_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.instance_join(fd, instance_id);
+	}
+	if( HPMHooks.count.HP_clif_instance_join_post ) {
+		void (*postHookFunc) (int *fd, int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_join_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_instance_join_post[hIndex].func;
+			postHookFunc(&fd, &instance_id);
+		}
+	}
+	return;
+}
+void HP_clif_instance_leave(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_instance_leave_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_instance_leave_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.instance_leave(fd);
+	}
+	if( HPMHooks.count.HP_clif_instance_leave_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_instance_leave_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_clif_catch_process(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_catch_process_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_catch_process_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_catch_process_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.catch_process(sd);
+	}
+	if( HPMHooks.count.HP_clif_catch_process_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_catch_process_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_catch_process_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_pet_roulette(struct map_session_data *sd, int data) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pet_roulette_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_roulette_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pet_roulette_pre[hIndex].func;
+			preHookFunc(sd, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pet_roulette(sd, data);
+	}
+	if( HPMHooks.count.HP_clif_pet_roulette_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_roulette_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pet_roulette_post[hIndex].func;
+			postHookFunc(sd, &data);
+		}
+	}
+	return;
+}
+void HP_clif_sendegg(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_sendegg_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendegg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_sendegg_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.sendegg(sd);
+	}
+	if( HPMHooks.count.HP_clif_sendegg_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendegg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_sendegg_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_send_petstatus(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_send_petstatus_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petstatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_send_petstatus_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.send_petstatus(sd);
+	}
+	if( HPMHooks.count.HP_clif_send_petstatus_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petstatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_send_petstatus_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_send_petdata(struct map_session_data *sd, struct pet_data *pd, int type, int param) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_send_petdata_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd, int *type, int *param);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_send_petdata_pre[hIndex].func;
+			preHookFunc(sd, pd, &type, &param);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.send_petdata(sd, pd, type, param);
+	}
+	if( HPMHooks.count.HP_clif_send_petdata_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct pet_data *pd, int *type, int *param);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_send_petdata_post[hIndex].func;
+			postHookFunc(sd, pd, &type, &param);
+		}
+	}
+	return;
+}
+void HP_clif_pet_emotion(struct pet_data *pd, int param) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pet_emotion_pre ) {
+		void (*preHookFunc) (struct pet_data *pd, int *param);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_emotion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pet_emotion_pre[hIndex].func;
+			preHookFunc(pd, &param);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pet_emotion(pd, param);
+	}
+	if( HPMHooks.count.HP_clif_pet_emotion_post ) {
+		void (*postHookFunc) (struct pet_data *pd, int *param);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_emotion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pet_emotion_post[hIndex].func;
+			postHookFunc(pd, &param);
+		}
+	}
+	return;
+}
+void HP_clif_pet_food(struct map_session_data *sd, int foodid, int fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pet_food_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *foodid, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_food_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pet_food_pre[hIndex].func;
+			preHookFunc(sd, &foodid, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pet_food(sd, foodid, fail);
+	}
+	if( HPMHooks.count.HP_clif_pet_food_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *foodid, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_food_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pet_food_post[hIndex].func;
+			postHookFunc(sd, &foodid, &fail);
+		}
+	}
+	return;
+}
+int HP_clif_friendslist_toggle_sub(struct map_session_data *sd, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_friendslist_toggle_sub_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.clif.friendslist_toggle_sub(sd, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_clif_friendslist_toggle_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_friendslist_send(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_friendslist_send_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_send_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_friendslist_send_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.friendslist_send(sd);
+	}
+	if( HPMHooks.count.HP_clif_friendslist_send_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_send_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_friendslist_send_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_friendslist_reqack(struct map_session_data *sd, struct map_session_data *f_sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_friendslist_reqack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *f_sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_reqack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_friendslist_reqack_pre[hIndex].func;
+			preHookFunc(sd, f_sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.friendslist_reqack(sd, f_sd, type);
+	}
+	if( HPMHooks.count.HP_clif_friendslist_reqack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *f_sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_reqack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_friendslist_reqack_post[hIndex].func;
+			postHookFunc(sd, f_sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_friendslist_toggle(struct map_session_data *sd, int account_id, int char_id, int online) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_friendslist_toggle_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, int *online);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_pre[hIndex].func;
+			preHookFunc(sd, &account_id, &char_id, &online);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.friendslist_toggle(sd, account_id, char_id, online);
+	}
+	if( HPMHooks.count.HP_clif_friendslist_toggle_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, int *online);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_post[hIndex].func;
+			postHookFunc(sd, &account_id, &char_id, &online);
+		}
+	}
+	return;
+}
+void HP_clif_friendlist_req(struct map_session_data *sd, int account_id, int char_id, const char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_friendlist_req_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendlist_req_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_friendlist_req_pre[hIndex].func;
+			preHookFunc(sd, &account_id, &char_id, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.friendlist_req(sd, account_id, char_id, name);
+	}
+	if( HPMHooks.count.HP_clif_friendlist_req_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendlist_req_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_friendlist_req_post[hIndex].func;
+			postHookFunc(sd, &account_id, &char_id, name);
+		}
+	}
+	return;
+}
+void HP_clif_GM_kickack(struct map_session_data *sd, int id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_GM_kickack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kickack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_GM_kickack_pre[hIndex].func;
+			preHookFunc(sd, &id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.GM_kickack(sd, id);
+	}
+	if( HPMHooks.count.HP_clif_GM_kickack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kickack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_GM_kickack_post[hIndex].func;
+			postHookFunc(sd, &id);
+		}
+	}
+	return;
+}
+void HP_clif_GM_kick(struct map_session_data *sd, struct map_session_data *tsd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_GM_kick_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_GM_kick_pre[hIndex].func;
+			preHookFunc(sd, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.GM_kick(sd, tsd);
+	}
+	if( HPMHooks.count.HP_clif_GM_kick_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_GM_kick_post[hIndex].func;
+			postHookFunc(sd, tsd);
+		}
+	}
+	return;
+}
+void HP_clif_manner_message(struct map_session_data *sd, uint32 type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_manner_message_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint32 *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_manner_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_manner_message_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.manner_message(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_manner_message_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint32 *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_manner_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_manner_message_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_GM_silence(struct map_session_data *sd, struct map_session_data *tsd, uint8 type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_GM_silence_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, uint8 *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_silence_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_GM_silence_pre[hIndex].func;
+			preHookFunc(sd, tsd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.GM_silence(sd, tsd, type);
+	}
+	if( HPMHooks.count.HP_clif_GM_silence_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, uint8 *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_silence_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_GM_silence_post[hIndex].func;
+			postHookFunc(sd, tsd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_account_name(struct map_session_data *sd, int account_id, const char *accname) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_account_name_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *account_id, const char *accname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_account_name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_account_name_pre[hIndex].func;
+			preHookFunc(sd, &account_id, accname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.account_name(sd, account_id, accname);
+	}
+	if( HPMHooks.count.HP_clif_account_name_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *account_id, const char *accname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_account_name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_account_name_post[hIndex].func;
+			postHookFunc(sd, &account_id, accname);
+		}
+	}
+	return;
+}
+void HP_clif_check(int fd, struct map_session_data *pl_sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_check_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *pl_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_check_pre[hIndex].func;
+			preHookFunc(&fd, pl_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.check(fd, pl_sd);
+	}
+	if( HPMHooks.count.HP_clif_check_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *pl_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_check_post[hIndex].func;
+			postHookFunc(&fd, pl_sd);
+		}
+	}
+	return;
+}
+void HP_clif_hominfo(struct map_session_data *sd, struct homun_data *hd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_hominfo_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct homun_data *hd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hominfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_hominfo_pre[hIndex].func;
+			preHookFunc(sd, hd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.hominfo(sd, hd, flag);
+	}
+	if( HPMHooks.count.HP_clif_hominfo_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct homun_data *hd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hominfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_hominfo_post[hIndex].func;
+			postHookFunc(sd, hd, &flag);
+		}
+	}
+	return;
+}
+int HP_clif_homskillinfoblock(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_homskillinfoblock_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillinfoblock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_homskillinfoblock_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.homskillinfoblock(sd);
+	}
+	if( HPMHooks.count.HP_clif_homskillinfoblock_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillinfoblock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_homskillinfoblock_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_homskillup(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_homskillup_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_homskillup_pre[hIndex].func;
+			preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.homskillup(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_clif_homskillup_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_homskillup_post[hIndex].func;
+			postHookFunc(sd, &skill_id);
+		}
+	}
+	return;
+}
+int HP_clif_hom_food(struct map_session_data *sd, int foodid, int fail) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_hom_food_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *foodid, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hom_food_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_hom_food_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &foodid, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.hom_food(sd, foodid, fail);
+	}
+	if( HPMHooks.count.HP_clif_hom_food_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *foodid, int *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hom_food_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_hom_food_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &foodid, &fail);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_send_homdata(struct map_session_data *sd, int state, int param) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_send_homdata_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *state, int *param);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_homdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_send_homdata_pre[hIndex].func;
+			preHookFunc(sd, &state, &param);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.send_homdata(sd, state, param);
+	}
+	if( HPMHooks.count.HP_clif_send_homdata_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *state, int *param);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_homdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_send_homdata_post[hIndex].func;
+			postHookFunc(sd, &state, &param);
+		}
+	}
+	return;
+}
+void HP_clif_quest_send_list(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_quest_send_list_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_send_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_quest_send_list_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.quest_send_list(sd);
+	}
+	if( HPMHooks.count.HP_clif_quest_send_list_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_send_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_quest_send_list_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_quest_send_mission(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_quest_send_mission_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_send_mission_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_quest_send_mission_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.quest_send_mission(sd);
+	}
+	if( HPMHooks.count.HP_clif_quest_send_mission_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_send_mission_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_quest_send_mission_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_quest_add(struct map_session_data *sd, struct quest *qd, int index) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_quest_add_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct quest *qd, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_quest_add_pre[hIndex].func;
+			preHookFunc(sd, qd, &index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.quest_add(sd, qd, index);
+	}
+	if( HPMHooks.count.HP_clif_quest_add_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct quest *qd, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_quest_add_post[hIndex].func;
+			postHookFunc(sd, qd, &index);
+		}
+	}
+	return;
+}
+void HP_clif_quest_delete(struct map_session_data *sd, int quest_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_quest_delete_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *quest_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_quest_delete_pre[hIndex].func;
+			preHookFunc(sd, &quest_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.quest_delete(sd, quest_id);
+	}
+	if( HPMHooks.count.HP_clif_quest_delete_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *quest_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_quest_delete_post[hIndex].func;
+			postHookFunc(sd, &quest_id);
+		}
+	}
+	return;
+}
+void HP_clif_quest_update_status(struct map_session_data *sd, int quest_id, bool active) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_quest_update_status_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *quest_id, bool *active);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_status_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_quest_update_status_pre[hIndex].func;
+			preHookFunc(sd, &quest_id, &active);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.quest_update_status(sd, quest_id, active);
+	}
+	if( HPMHooks.count.HP_clif_quest_update_status_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *quest_id, bool *active);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_status_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_quest_update_status_post[hIndex].func;
+			postHookFunc(sd, &quest_id, &active);
+		}
+	}
+	return;
+}
+void HP_clif_quest_update_objective(struct map_session_data *sd, struct quest *qd, int index) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_quest_update_objective_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct quest *qd, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_objective_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_quest_update_objective_pre[hIndex].func;
+			preHookFunc(sd, qd, &index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.quest_update_objective(sd, qd, index);
+	}
+	if( HPMHooks.count.HP_clif_quest_update_objective_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct quest *qd, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_objective_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_quest_update_objective_post[hIndex].func;
+			postHookFunc(sd, qd, &index);
+		}
+	}
+	return;
+}
+void HP_clif_quest_show_event(struct map_session_data *sd, struct block_list *bl, short state, short color) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_quest_show_event_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, short *state, short *color);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_show_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_quest_show_event_pre[hIndex].func;
+			preHookFunc(sd, bl, &state, &color);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.quest_show_event(sd, bl, state, color);
+	}
+	if( HPMHooks.count.HP_clif_quest_show_event_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl, short *state, short *color);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_show_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_quest_show_event_post[hIndex].func;
+			postHookFunc(sd, bl, &state, &color);
+		}
+	}
+	return;
+}
+void HP_clif_mail_window(int fd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_window_pre ) {
+		void (*preHookFunc) (int *fd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_window_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_window_pre[hIndex].func;
+			preHookFunc(&fd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_window(fd, flag);
+	}
+	if( HPMHooks.count.HP_clif_mail_window_post ) {
+		void (*postHookFunc) (int *fd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_window_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_window_post[hIndex].func;
+			postHookFunc(&fd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_mail_read(struct map_session_data *sd, int mail_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_read_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_read_pre[hIndex].func;
+			preHookFunc(sd, &mail_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_read(sd, mail_id);
+	}
+	if( HPMHooks.count.HP_clif_mail_read_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_read_post[hIndex].func;
+			postHookFunc(sd, &mail_id);
+		}
+	}
+	return;
+}
+void HP_clif_mail_delete(int fd, int mail_id, short fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_delete_pre ) {
+		void (*preHookFunc) (int *fd, int *mail_id, short *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_delete_pre[hIndex].func;
+			preHookFunc(&fd, &mail_id, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_delete(fd, mail_id, fail);
+	}
+	if( HPMHooks.count.HP_clif_mail_delete_post ) {
+		void (*postHookFunc) (int *fd, int *mail_id, short *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_delete_post[hIndex].func;
+			postHookFunc(&fd, &mail_id, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_mail_return(int fd, int mail_id, short fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_return_pre ) {
+		void (*preHookFunc) (int *fd, int *mail_id, short *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_return_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_return_pre[hIndex].func;
+			preHookFunc(&fd, &mail_id, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_return(fd, mail_id, fail);
+	}
+	if( HPMHooks.count.HP_clif_mail_return_post ) {
+		void (*postHookFunc) (int *fd, int *mail_id, short *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_return_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_return_post[hIndex].func;
+			postHookFunc(&fd, &mail_id, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_mail_send(int fd, bool fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_send_pre ) {
+		void (*preHookFunc) (int *fd, bool *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_send_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_send_pre[hIndex].func;
+			preHookFunc(&fd, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_send(fd, fail);
+	}
+	if( HPMHooks.count.HP_clif_mail_send_post ) {
+		void (*postHookFunc) (int *fd, bool *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_send_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_send_post[hIndex].func;
+			postHookFunc(&fd, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_mail_new(int fd, int mail_id, const char *sender, const char *title) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_new_pre ) {
+		void (*preHookFunc) (int *fd, int *mail_id, const char *sender, const char *title);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_new_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_new_pre[hIndex].func;
+			preHookFunc(&fd, &mail_id, sender, title);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_new(fd, mail_id, sender, title);
+	}
+	if( HPMHooks.count.HP_clif_mail_new_post ) {
+		void (*postHookFunc) (int *fd, int *mail_id, const char *sender, const char *title);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_new_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_new_post[hIndex].func;
+			postHookFunc(&fd, &mail_id, sender, title);
+		}
+	}
+	return;
+}
+void HP_clif_mail_refreshinbox(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_refreshinbox_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_refreshinbox_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_refreshinbox_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_refreshinbox(sd);
+	}
+	if( HPMHooks.count.HP_clif_mail_refreshinbox_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_refreshinbox_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_refreshinbox_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_mail_getattachment(int fd, uint8 flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_getattachment_pre ) {
+		void (*preHookFunc) (int *fd, uint8 *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_getattachment_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_getattachment_pre[hIndex].func;
+			preHookFunc(&fd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_getattachment(fd, flag);
+	}
+	if( HPMHooks.count.HP_clif_mail_getattachment_post ) {
+		void (*postHookFunc) (int *fd, uint8 *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_getattachment_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_getattachment_post[hIndex].func;
+			postHookFunc(&fd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_mail_setattachment(int fd, int index, uint8 flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mail_setattachment_pre ) {
+		void (*preHookFunc) (int *fd, int *index, uint8 *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_setattachment_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mail_setattachment_pre[hIndex].func;
+			preHookFunc(&fd, &index, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mail_setattachment(fd, index, flag);
+	}
+	if( HPMHooks.count.HP_clif_mail_setattachment_post ) {
+		void (*postHookFunc) (int *fd, int *index, uint8 *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_setattachment_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mail_setattachment_post[hIndex].func;
+			postHookFunc(&fd, &index, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_auction_openwindow(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_auction_openwindow_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_openwindow_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_auction_openwindow_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.auction_openwindow(sd);
+	}
+	if( HPMHooks.count.HP_clif_auction_openwindow_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_openwindow_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_auction_openwindow_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_auction_results(struct map_session_data *sd, short count, short pages, uint8 *buf) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_auction_results_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *count, short *pages, uint8 *buf);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_results_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_auction_results_pre[hIndex].func;
+			preHookFunc(sd, &count, &pages, buf);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.auction_results(sd, count, pages, buf);
+	}
+	if( HPMHooks.count.HP_clif_auction_results_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *count, short *pages, uint8 *buf);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_results_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_auction_results_post[hIndex].func;
+			postHookFunc(sd, &count, &pages, buf);
+		}
+	}
+	return;
+}
+void HP_clif_auction_message(int fd, unsigned char flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_auction_message_pre ) {
+		void (*preHookFunc) (int *fd, unsigned char *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_auction_message_pre[hIndex].func;
+			preHookFunc(&fd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.auction_message(fd, flag);
+	}
+	if( HPMHooks.count.HP_clif_auction_message_post ) {
+		void (*postHookFunc) (int *fd, unsigned char *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_auction_message_post[hIndex].func;
+			postHookFunc(&fd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_auction_close(int fd, unsigned char flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_auction_close_pre ) {
+		void (*preHookFunc) (int *fd, unsigned char *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_auction_close_pre[hIndex].func;
+			preHookFunc(&fd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.auction_close(fd, flag);
+	}
+	if( HPMHooks.count.HP_clif_auction_close_post ) {
+		void (*postHookFunc) (int *fd, unsigned char *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_auction_close_post[hIndex].func;
+			postHookFunc(&fd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_auction_setitem(int fd, int index, bool fail) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_auction_setitem_pre ) {
+		void (*preHookFunc) (int *fd, int *index, bool *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_setitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_auction_setitem_pre[hIndex].func;
+			preHookFunc(&fd, &index, &fail);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.auction_setitem(fd, index, fail);
+	}
+	if( HPMHooks.count.HP_clif_auction_setitem_post ) {
+		void (*postHookFunc) (int *fd, int *index, bool *fail);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_setitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_auction_setitem_post[hIndex].func;
+			postHookFunc(&fd, &index, &fail);
+		}
+	}
+	return;
+}
+void HP_clif_mercenary_info(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mercenary_info_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mercenary_info_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mercenary_info(sd);
+	}
+	if( HPMHooks.count.HP_clif_mercenary_info_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mercenary_info_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_mercenary_skillblock(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mercenary_skillblock_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_skillblock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mercenary_skillblock_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mercenary_skillblock(sd);
+	}
+	if( HPMHooks.count.HP_clif_mercenary_skillblock_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_skillblock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mercenary_skillblock_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_mercenary_message(struct map_session_data *sd, int message) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mercenary_message_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mercenary_message_pre[hIndex].func;
+			preHookFunc(sd, &message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mercenary_message(sd, message);
+	}
+	if( HPMHooks.count.HP_clif_mercenary_message_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mercenary_message_post[hIndex].func;
+			postHookFunc(sd, &message);
+		}
+	}
+	return;
+}
+void HP_clif_mercenary_updatestatus(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_mercenary_updatestatus_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_updatestatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_mercenary_updatestatus_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.mercenary_updatestatus(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_mercenary_updatestatus_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_updatestatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_mercenary_updatestatus_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_rental_time(int fd, int nameid, int seconds) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_rental_time_pre ) {
+		void (*preHookFunc) (int *fd, int *nameid, int *seconds);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_rental_time_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_rental_time_pre[hIndex].func;
+			preHookFunc(&fd, &nameid, &seconds);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.rental_time(fd, nameid, seconds);
+	}
+	if( HPMHooks.count.HP_clif_rental_time_post ) {
+		void (*postHookFunc) (int *fd, int *nameid, int *seconds);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_rental_time_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_rental_time_post[hIndex].func;
+			postHookFunc(&fd, &nameid, &seconds);
+		}
+	}
+	return;
+}
+void HP_clif_rental_expired(int fd, int index, int nameid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_rental_expired_pre ) {
+		void (*preHookFunc) (int *fd, int *index, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_rental_expired_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_rental_expired_pre[hIndex].func;
+			preHookFunc(&fd, &index, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.rental_expired(fd, index, nameid);
+	}
+	if( HPMHooks.count.HP_clif_rental_expired_post ) {
+		void (*postHookFunc) (int *fd, int *index, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_rental_expired_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_rental_expired_post[hIndex].func;
+			postHookFunc(&fd, &index, &nameid);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingRegisterAck(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingRegisterAck_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRegisterAck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingRegisterAck_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingRegisterAck(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingRegisterAck_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRegisterAck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingRegisterAck_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingDeleteAck(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingDeleteAck_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteAck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteAck_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingDeleteAck(sd, flag);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingDeleteAck_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteAck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteAck_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingSearchAck(int fd, struct party_booking_ad_info **results, int count, bool more_result) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingSearchAck_pre ) {
+		void (*preHookFunc) (int *fd, struct party_booking_ad_info **results, int *count, bool *more_result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSearchAck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingSearchAck_pre[hIndex].func;
+			preHookFunc(&fd, results, &count, &more_result);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingSearchAck(fd, results, count, more_result);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingSearchAck_post ) {
+		void (*postHookFunc) (int *fd, struct party_booking_ad_info **results, int *count, bool *more_result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSearchAck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingSearchAck_post[hIndex].func;
+			postHookFunc(&fd, results, &count, &more_result);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingUpdateNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingUpdateNotify_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingUpdateNotify_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingUpdateNotify_pre[hIndex].func;
+			preHookFunc(sd, pb_ad);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingUpdateNotify(sd, pb_ad);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingUpdateNotify_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingUpdateNotify_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingUpdateNotify_post[hIndex].func;
+			postHookFunc(sd, pb_ad);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingDeleteNotify(struct map_session_data *sd, int index) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingDeleteNotify_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteNotify_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteNotify_pre[hIndex].func;
+			preHookFunc(sd, &index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingDeleteNotify(sd, index);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingDeleteNotify_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteNotify_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteNotify_post[hIndex].func;
+			postHookFunc(sd, &index);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingInsertNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingInsertNotify_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingInsertNotify_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingInsertNotify_pre[hIndex].func;
+			preHookFunc(sd, pb_ad);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingInsertNotify(sd, pb_ad);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingInsertNotify_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingInsertNotify_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingInsertNotify_post[hIndex].func;
+			postHookFunc(sd, pb_ad);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingVolunteerInfo(int index, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_pre ) {
+		void (*preHookFunc) (int *index, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingVolunteerInfo_pre[hIndex].func;
+			preHookFunc(&index, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingVolunteerInfo(index, sd);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_post ) {
+		void (*postHookFunc) (int *index, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingVolunteerInfo_post[hIndex].func;
+			postHookFunc(&index, sd);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingRefuseVolunteer(unsigned long aid, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_pre ) {
+		void (*preHookFunc) (unsigned long *aid, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingRefuseVolunteer_pre[hIndex].func;
+			preHookFunc(&aid, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingRefuseVolunteer(aid, sd);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_post ) {
+		void (*postHookFunc) (unsigned long *aid, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingRefuseVolunteer_post[hIndex].func;
+			postHookFunc(&aid, sd);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingCancelVolunteer(int index, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_pre ) {
+		void (*preHookFunc) (int *index, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingCancelVolunteer_pre[hIndex].func;
+			preHookFunc(&index, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingCancelVolunteer(index, sd);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_post ) {
+		void (*postHookFunc) (int *index, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingCancelVolunteer_post[hIndex].func;
+			postHookFunc(&index, sd);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingAddFilteringList(int index, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingAddFilteringList_pre ) {
+		void (*preHookFunc) (int *index, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingAddFilteringList_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingAddFilteringList_pre[hIndex].func;
+			preHookFunc(&index, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingAddFilteringList(index, sd);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingAddFilteringList_post ) {
+		void (*postHookFunc) (int *index, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingAddFilteringList_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingAddFilteringList_post[hIndex].func;
+			postHookFunc(&index, sd);
+		}
+	}
+	return;
+}
+void HP_clif_PartyBookingSubFilteringList(int gid, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_PartyBookingSubFilteringList_pre ) {
+		void (*preHookFunc) (int *gid, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSubFilteringList_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_PartyBookingSubFilteringList_pre[hIndex].func;
+			preHookFunc(&gid, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.PartyBookingSubFilteringList(gid, sd);
+	}
+	if( HPMHooks.count.HP_clif_PartyBookingSubFilteringList_post ) {
+		void (*postHookFunc) (int *gid, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSubFilteringList_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_PartyBookingSubFilteringList_post[hIndex].func;
+			postHookFunc(&gid, sd);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_open(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_open_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_open_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_open(sd);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_open_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_open_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_open_failed(struct map_session_data *sd, unsigned short result, unsigned int weight) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_open_failed_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *result, unsigned int *weight);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_failed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_open_failed_pre[hIndex].func;
+			preHookFunc(sd, &result, &weight);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_open_failed(sd, result, weight);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_open_failed_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *result, unsigned int *weight);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_failed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_open_failed_post[hIndex].func;
+			postHookFunc(sd, &result, &weight);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_myitemlist(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_myitemlist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_myitemlist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_myitemlist_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_myitemlist(sd);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_myitemlist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_myitemlist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_myitemlist_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_entry(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_entry_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_entry(sd);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_entry_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_entry_single(struct map_session_data *sd, struct map_session_data *pl_sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_entry_single_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_single_pre[hIndex].func;
+			preHookFunc(sd, pl_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_entry_single(sd, pl_sd);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_entry_single_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_single_post[hIndex].func;
+			postHookFunc(sd, pl_sd);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_disappear_entry(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_disappear_entry_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_disappear_entry_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_disappear_entry(sd);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_disappear_entry_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_disappear_entry_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_disappear_entry_single(struct map_session_data *sd, struct map_session_data *pl_sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_disappear_entry_single_pre[hIndex].func;
+			preHookFunc(sd, pl_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_disappear_entry_single(sd, pl_sd);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_disappear_entry_single_post[hIndex].func;
+			postHookFunc(sd, pl_sd);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_itemlist(struct map_session_data *sd, struct map_session_data *pl_sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_itemlist_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_itemlist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_itemlist_pre[hIndex].func;
+			preHookFunc(sd, pl_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_itemlist(sd, pl_sd);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_itemlist_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_itemlist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_itemlist_post[hIndex].func;
+			postHookFunc(sd, pl_sd);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_trade_failed_buyer(struct map_session_data *sd, short result) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_buyer_pre[hIndex].func;
+			preHookFunc(sd, &result);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_trade_failed_buyer(sd, result);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *result);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_buyer_post[hIndex].func;
+			postHookFunc(sd, &result);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_update_item(struct map_session_data *sd, unsigned short nameid, unsigned short amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_update_item_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_update_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_update_item_pre[hIndex].func;
+			preHookFunc(sd, &nameid, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_update_item(sd, nameid, amount);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_update_item_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_update_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_update_item_post[hIndex].func;
+			postHookFunc(sd, &nameid, &amount);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_delete_item(struct map_session_data *sd, short index, unsigned short amount, int price) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_delete_item_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *index, unsigned short *amount, int *price);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_delete_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_delete_item_pre[hIndex].func;
+			preHookFunc(sd, &index, &amount, &price);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_delete_item(sd, index, amount, price);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_delete_item_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *index, unsigned short *amount, int *price);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_delete_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_delete_item_post[hIndex].func;
+			postHookFunc(sd, &index, &amount, &price);
+		}
+	}
+	return;
+}
+void HP_clif_buyingstore_trade_failed_seller(struct map_session_data *sd, short result, unsigned short nameid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *result, unsigned short *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_seller_pre[hIndex].func;
+			preHookFunc(sd, &result, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.buyingstore_trade_failed_seller(sd, result, nameid);
+	}
+	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *result, unsigned short *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_seller_post[hIndex].func;
+			postHookFunc(sd, &result, &nameid);
+		}
+	}
+	return;
+}
+void HP_clif_search_store_info_ack(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_search_store_info_ack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_search_store_info_ack_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.search_store_info_ack(sd);
+	}
+	if( HPMHooks.count.HP_clif_search_store_info_ack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_search_store_info_ack_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_search_store_info_failed(struct map_session_data *sd, unsigned char reason) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_search_store_info_failed_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *reason);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_failed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_search_store_info_failed_pre[hIndex].func;
+			preHookFunc(sd, &reason);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.search_store_info_failed(sd, reason);
+	}
+	if( HPMHooks.count.HP_clif_search_store_info_failed_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *reason);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_failed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_search_store_info_failed_post[hIndex].func;
+			postHookFunc(sd, &reason);
+		}
+	}
+	return;
+}
+void HP_clif_open_search_store_info(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_open_search_store_info_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_open_search_store_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_open_search_store_info_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.open_search_store_info(sd);
+	}
+	if( HPMHooks.count.HP_clif_open_search_store_info_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_open_search_store_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_open_search_store_info_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_search_store_info_click_ack(struct map_session_data *sd, short x, short y) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_search_store_info_click_ack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_click_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_search_store_info_click_ack_pre[hIndex].func;
+			preHookFunc(sd, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.search_store_info_click_ack(sd, x, y);
+	}
+	if( HPMHooks.count.HP_clif_search_store_info_click_ack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_click_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_search_store_info_click_ack_post[hIndex].func;
+			postHookFunc(sd, &x, &y);
+		}
+	}
+	return;
+}
+void HP_clif_elemental_info(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_elemental_info_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_elemental_info_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.elemental_info(sd);
+	}
+	if( HPMHooks.count.HP_clif_elemental_info_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_elemental_info_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_elemental_updatestatus(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_elemental_updatestatus_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_updatestatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_elemental_updatestatus_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.elemental_updatestatus(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_elemental_updatestatus_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_updatestatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_elemental_updatestatus_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_bgqueue_ack(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK response, unsigned char arena_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bgqueue_ack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK *response, unsigned char *arena_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bgqueue_ack_pre[hIndex].func;
+			preHookFunc(sd, &response, &arena_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bgqueue_ack(sd, response, arena_id);
+	}
+	if( HPMHooks.count.HP_clif_bgqueue_ack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK *response, unsigned char *arena_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bgqueue_ack_post[hIndex].func;
+			postHookFunc(sd, &response, &arena_id);
+		}
+	}
+	return;
+}
+void HP_clif_bgqueue_notice_delete(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED response, char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bgqueue_notice_delete_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED *response, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_notice_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bgqueue_notice_delete_pre[hIndex].func;
+			preHookFunc(sd, &response, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bgqueue_notice_delete(sd, response, name);
+	}
+	if( HPMHooks.count.HP_clif_bgqueue_notice_delete_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED *response, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_notice_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bgqueue_notice_delete_post[hIndex].func;
+			postHookFunc(sd, &response, name);
+		}
+	}
+	return;
+}
+void HP_clif_bgqueue_update_info(struct map_session_data *sd, unsigned char arena_id, int position) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bgqueue_update_info_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *arena_id, int *position);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_update_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bgqueue_update_info_pre[hIndex].func;
+			preHookFunc(sd, &arena_id, &position);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bgqueue_update_info(sd, arena_id, position);
+	}
+	if( HPMHooks.count.HP_clif_bgqueue_update_info_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *arena_id, int *position);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_update_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bgqueue_update_info_post[hIndex].func;
+			postHookFunc(sd, &arena_id, &position);
+		}
+	}
+	return;
+}
+void HP_clif_bgqueue_joined(struct map_session_data *sd, int pos) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bgqueue_joined_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_joined_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bgqueue_joined_pre[hIndex].func;
+			preHookFunc(sd, &pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bgqueue_joined(sd, pos);
+	}
+	if( HPMHooks.count.HP_clif_bgqueue_joined_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_joined_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bgqueue_joined_post[hIndex].func;
+			postHookFunc(sd, &pos);
+		}
+	}
+	return;
+}
+void HP_clif_bgqueue_pcleft(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bgqueue_pcleft_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_pcleft_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bgqueue_pcleft_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bgqueue_pcleft(sd);
+	}
+	if( HPMHooks.count.HP_clif_bgqueue_pcleft_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_pcleft_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bgqueue_pcleft_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_bgqueue_battlebegins(struct map_session_data *sd, unsigned char arena_id, enum send_target target) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bgqueue_battlebegins_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *arena_id, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_battlebegins_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bgqueue_battlebegins_pre[hIndex].func;
+			preHookFunc(sd, &arena_id, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bgqueue_battlebegins(sd, arena_id, target);
+	}
+	if( HPMHooks.count.HP_clif_bgqueue_battlebegins_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *arena_id, enum send_target *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_battlebegins_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bgqueue_battlebegins_post[hIndex].func;
+			postHookFunc(sd, &arena_id, &target);
+		}
+	}
+	return;
+}
+void HP_clif_adopt_reply(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_adopt_reply_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_reply_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_adopt_reply_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.adopt_reply(sd, type);
+	}
+	if( HPMHooks.count.HP_clif_adopt_reply_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_reply_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_adopt_reply_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+void HP_clif_adopt_request(struct map_session_data *sd, struct map_session_data *src, int p_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_adopt_request_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *src, int *p_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_request_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_adopt_request_pre[hIndex].func;
+			preHookFunc(sd, src, &p_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.adopt_request(sd, src, p_id);
+	}
+	if( HPMHooks.count.HP_clif_adopt_request_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *src, int *p_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_request_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_adopt_request_post[hIndex].func;
+			postHookFunc(sd, src, &p_id);
+		}
+	}
+	return;
+}
+void HP_clif_readbook(int fd, int book_id, int page) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_readbook_pre ) {
+		void (*preHookFunc) (int *fd, int *book_id, int *page);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_readbook_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_readbook_pre[hIndex].func;
+			preHookFunc(&fd, &book_id, &page);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.readbook(fd, book_id, page);
+	}
+	if( HPMHooks.count.HP_clif_readbook_post ) {
+		void (*postHookFunc) (int *fd, int *book_id, int *page);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_readbook_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_readbook_post[hIndex].func;
+			postHookFunc(&fd, &book_id, &page);
+		}
+	}
+	return;
+}
+void HP_clif_notify_time(struct map_session_data *sd, unsigned long time) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_notify_time_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned long *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_time_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_notify_time_pre[hIndex].func;
+			preHookFunc(sd, &time);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.notify_time(sd, time);
+	}
+	if( HPMHooks.count.HP_clif_notify_time_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned long *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_time_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_notify_time_post[hIndex].func;
+			postHookFunc(sd, &time);
+		}
+	}
+	return;
+}
+void HP_clif_user_count(struct map_session_data *sd, int count) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_user_count_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_user_count_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_user_count_pre[hIndex].func;
+			preHookFunc(sd, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.user_count(sd, count);
+	}
+	if( HPMHooks.count.HP_clif_user_count_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_user_count_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_user_count_post[hIndex].func;
+			postHookFunc(sd, &count);
+		}
+	}
+	return;
+}
+void HP_clif_noask_sub(struct map_session_data *src, struct map_session_data *target, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_noask_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *src, struct map_session_data *target, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_noask_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_noask_sub_pre[hIndex].func;
+			preHookFunc(src, target, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.noask_sub(src, target, type);
+	}
+	if( HPMHooks.count.HP_clif_noask_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *src, struct map_session_data *target, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_noask_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_noask_sub_post[hIndex].func;
+			postHookFunc(src, target, &type);
+		}
+	}
+	return;
+}
+void HP_clif_bc_ready(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_bc_ready_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bc_ready_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_bc_ready_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.bc_ready();
+	}
+	if( HPMHooks.count.HP_clif_bc_ready_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bc_ready_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_bc_ready_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_clif_undisguise_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_clif_undisguise_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_undisguise_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_undisguise_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.clif.undisguise_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_clif_undisguise_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_undisguise_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_undisguise_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_clif_chsys_create(struct hChSysCh *channel, char *name, char *pass, unsigned char color) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_create_pre ) {
+		void (*preHookFunc) (struct hChSysCh *channel, char *name, char *pass, unsigned char *color);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_create_pre[hIndex].func;
+			preHookFunc(channel, name, pass, &color);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_create(channel, name, pass, color);
+	}
+	if( HPMHooks.count.HP_clif_chsys_create_post ) {
+		void (*postHookFunc) (struct hChSysCh *channel, char *name, char *pass, unsigned char *color);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_create_post[hIndex].func;
+			postHookFunc(channel, name, pass, &color);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_msg(struct hChSysCh *channel, struct map_session_data *sd, char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_msg_pre ) {
+		void (*preHookFunc) (struct hChSysCh *channel, struct map_session_data *sd, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_msg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_msg_pre[hIndex].func;
+			preHookFunc(channel, sd, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_msg(channel, sd, msg);
+	}
+	if( HPMHooks.count.HP_clif_chsys_msg_post ) {
+		void (*postHookFunc) (struct hChSysCh *channel, struct map_session_data *sd, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_msg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_msg_post[hIndex].func;
+			postHookFunc(channel, sd, msg);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_msg2(struct hChSysCh *channel, char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_msg2_pre ) {
+		void (*preHookFunc) (struct hChSysCh *channel, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_msg2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_msg2_pre[hIndex].func;
+			preHookFunc(channel, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_msg2(channel, msg);
+	}
+	if( HPMHooks.count.HP_clif_chsys_msg2_post ) {
+		void (*postHookFunc) (struct hChSysCh *channel, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_msg2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_msg2_post[hIndex].func;
+			postHookFunc(channel, msg);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_send(struct hChSysCh *channel, struct map_session_data *sd, const char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_send_pre ) {
+		void (*preHookFunc) (struct hChSysCh *channel, struct map_session_data *sd, const char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_send_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_send_pre[hIndex].func;
+			preHookFunc(channel, sd, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_send(channel, sd, msg);
+	}
+	if( HPMHooks.count.HP_clif_chsys_send_post ) {
+		void (*postHookFunc) (struct hChSysCh *channel, struct map_session_data *sd, const char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_send_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_send_post[hIndex].func;
+			postHookFunc(channel, sd, msg);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_join(struct hChSysCh *channel, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_join_pre ) {
+		void (*preHookFunc) (struct hChSysCh *channel, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_join_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_join_pre[hIndex].func;
+			preHookFunc(channel, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_join(channel, sd);
+	}
+	if( HPMHooks.count.HP_clif_chsys_join_post ) {
+		void (*postHookFunc) (struct hChSysCh *channel, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_join_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_join_post[hIndex].func;
+			postHookFunc(channel, sd);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_left(struct hChSysCh *channel, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_left_pre ) {
+		void (*preHookFunc) (struct hChSysCh *channel, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_left_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_left_pre[hIndex].func;
+			preHookFunc(channel, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_left(channel, sd);
+	}
+	if( HPMHooks.count.HP_clif_chsys_left_post ) {
+		void (*postHookFunc) (struct hChSysCh *channel, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_left_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_left_post[hIndex].func;
+			postHookFunc(channel, sd);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_delete(struct hChSysCh *channel) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_delete_pre ) {
+		void (*preHookFunc) (struct hChSysCh *channel);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_delete_pre[hIndex].func;
+			preHookFunc(channel);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_delete(channel);
+	}
+	if( HPMHooks.count.HP_clif_chsys_delete_post ) {
+		void (*postHookFunc) (struct hChSysCh *channel);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_delete_post[hIndex].func;
+			postHookFunc(channel);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_mjoin(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_mjoin_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_mjoin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_mjoin_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_mjoin(sd);
+	}
+	if( HPMHooks.count.HP_clif_chsys_mjoin_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_mjoin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_mjoin_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_quit(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_quit_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_quit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_quit_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_quit(sd);
+	}
+	if( HPMHooks.count.HP_clif_chsys_quit_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_quit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_quit_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_quitg(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_quitg_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_quitg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_quitg_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_quitg(sd);
+	}
+	if( HPMHooks.count.HP_clif_chsys_quitg_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_quitg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_quitg_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_gjoin(struct guild *g1, struct guild *g2) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_gjoin_pre ) {
+		void (*preHookFunc) (struct guild *g1, struct guild *g2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_gjoin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_gjoin_pre[hIndex].func;
+			preHookFunc(g1, g2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_gjoin(g1, g2);
+	}
+	if( HPMHooks.count.HP_clif_chsys_gjoin_post ) {
+		void (*postHookFunc) (struct guild *g1, struct guild *g2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_gjoin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_gjoin_post[hIndex].func;
+			postHookFunc(g1, g2);
+		}
+	}
+	return;
+}
+void HP_clif_chsys_gleave(struct guild *g1, struct guild *g2) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chsys_gleave_pre ) {
+		void (*preHookFunc) (struct guild *g1, struct guild *g2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_gleave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chsys_gleave_pre[hIndex].func;
+			preHookFunc(g1, g2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chsys_gleave(g1, g2);
+	}
+	if( HPMHooks.count.HP_clif_chsys_gleave_post ) {
+		void (*postHookFunc) (struct guild *g1, struct guild *g2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_gleave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chsys_gleave_post[hIndex].func;
+			postHookFunc(g1, g2);
+		}
+	}
+	return;
+}
+void HP_clif_pWantToConnection(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pWantToConnection_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWantToConnection_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pWantToConnection_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pWantToConnection(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pWantToConnection_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWantToConnection_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pWantToConnection_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pLoadEndAck(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pLoadEndAck_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLoadEndAck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pLoadEndAck_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pLoadEndAck(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pLoadEndAck_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLoadEndAck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pLoadEndAck_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pTickSend(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTickSend_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTickSend_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTickSend_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTickSend(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTickSend_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTickSend_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTickSend_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pHotkey(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pHotkey_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkey_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pHotkey_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pHotkey(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pHotkey_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkey_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pHotkey_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pProgressbar(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pProgressbar_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProgressbar_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pProgressbar_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pProgressbar(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pProgressbar_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProgressbar_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pProgressbar_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pWalkToXY(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pWalkToXY_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWalkToXY_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pWalkToXY_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pWalkToXY(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pWalkToXY_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWalkToXY_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pWalkToXY_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pQuitGame(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pQuitGame_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pQuitGame_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pQuitGame_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pQuitGame(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pQuitGame_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pQuitGame_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pQuitGame_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGetCharNameRequest(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGetCharNameRequest_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetCharNameRequest_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGetCharNameRequest_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGetCharNameRequest(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGetCharNameRequest_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetCharNameRequest_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGetCharNameRequest_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGlobalMessage(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGlobalMessage_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGlobalMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGlobalMessage_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGlobalMessage(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGlobalMessage_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGlobalMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGlobalMessage_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMapMove(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMapMove_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMapMove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMapMove_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMapMove(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMapMove_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMapMove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMapMove_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pChangeDir(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pChangeDir_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeDir_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pChangeDir_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pChangeDir(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pChangeDir_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeDir_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pChangeDir_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pEmotion(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pEmotion_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEmotion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pEmotion_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pEmotion(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pEmotion_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEmotion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pEmotion_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pHowManyConnections(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pHowManyConnections_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHowManyConnections_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pHowManyConnections_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pHowManyConnections(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pHowManyConnections_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHowManyConnections_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pHowManyConnections_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pActionRequest(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pActionRequest_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pActionRequest_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pActionRequest(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pActionRequest_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pActionRequest_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pActionRequest_sub(struct map_session_data *sd, int action_type, int target_id, unsigned int tick) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pActionRequest_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *action_type, int *target_id, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pActionRequest_sub_pre[hIndex].func;
+			preHookFunc(sd, &action_type, &target_id, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pActionRequest_sub(sd, action_type, target_id, tick);
+	}
+	if( HPMHooks.count.HP_clif_pActionRequest_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *action_type, int *target_id, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pActionRequest_sub_post[hIndex].func;
+			postHookFunc(sd, &action_type, &target_id, &tick);
+		}
+	}
+	return;
+}
+void HP_clif_pRestart(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pRestart_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRestart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pRestart_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pRestart(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pRestart_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRestart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pRestart_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pWisMessage(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pWisMessage_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWisMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pWisMessage_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pWisMessage(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pWisMessage_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWisMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pWisMessage_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pBroadcast(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pBroadcast_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBroadcast_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pBroadcast_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pBroadcast(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pBroadcast_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBroadcast_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pBroadcast_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pTakeItem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTakeItem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTakeItem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTakeItem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTakeItem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTakeItem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTakeItem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTakeItem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pDropItem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pDropItem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDropItem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pDropItem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pDropItem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pDropItem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDropItem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pDropItem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pUseItem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseItem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseItem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseItem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseItem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pUseItem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseItem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseItem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pEquipItem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pEquipItem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipItem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pEquipItem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pEquipItem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pEquipItem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipItem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pEquipItem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pUnequipItem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUnequipItem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUnequipItem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUnequipItem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUnequipItem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pUnequipItem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUnequipItem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUnequipItem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcClicked(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcClicked_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcClicked_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcClicked_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcClicked(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcClicked_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcClicked_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcClicked_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcBuySellSelected(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcBuySellSelected_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuySellSelected_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcBuySellSelected_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcBuySellSelected(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcBuySellSelected_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuySellSelected_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcBuySellSelected_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcBuyListSend(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcBuyListSend_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuyListSend_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcBuyListSend_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcBuyListSend(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcBuyListSend_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuyListSend_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcBuyListSend_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcSellListSend(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcSellListSend_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSellListSend_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcSellListSend_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcSellListSend(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcSellListSend_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSellListSend_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcSellListSend_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCreateChatRoom(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCreateChatRoom_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateChatRoom_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCreateChatRoom_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCreateChatRoom(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCreateChatRoom_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateChatRoom_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCreateChatRoom_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pChatAddMember(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pChatAddMember_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatAddMember_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pChatAddMember_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pChatAddMember(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pChatAddMember_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatAddMember_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pChatAddMember_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pChatRoomStatusChange(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pChatRoomStatusChange_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatRoomStatusChange_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pChatRoomStatusChange_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pChatRoomStatusChange(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pChatRoomStatusChange_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatRoomStatusChange_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pChatRoomStatusChange_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pChangeChatOwner(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pChangeChatOwner_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeChatOwner_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pChangeChatOwner_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pChangeChatOwner(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pChangeChatOwner_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeChatOwner_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pChangeChatOwner_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pKickFromChat(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pKickFromChat_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pKickFromChat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pKickFromChat_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pKickFromChat(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pKickFromChat_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pKickFromChat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pKickFromChat_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pChatLeave(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pChatLeave_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatLeave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pChatLeave_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pChatLeave(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pChatLeave_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatLeave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pChatLeave_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pTradeRequest(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTradeRequest_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeRequest_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTradeRequest_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTradeRequest(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTradeRequest_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeRequest_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTradeRequest_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_chann_config_read(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_chann_config_read_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chann_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_chann_config_read_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.chann_config_read();
+	}
+	if( HPMHooks.count.HP_clif_chann_config_read_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chann_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_chann_config_read_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_clif_pTradeAck(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTradeAck_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTradeAck_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTradeAck(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTradeAck_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTradeAck_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pTradeAddItem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTradeAddItem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAddItem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTradeAddItem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTradeAddItem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTradeAddItem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAddItem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTradeAddItem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pTradeOk(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTradeOk_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeOk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTradeOk_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTradeOk(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTradeOk_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeOk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTradeOk_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pTradeCancel(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTradeCancel_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCancel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTradeCancel_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTradeCancel(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTradeCancel_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCancel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTradeCancel_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pTradeCommit(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTradeCommit_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCommit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTradeCommit_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTradeCommit(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTradeCommit_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCommit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTradeCommit_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pStopAttack(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pStopAttack_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStopAttack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pStopAttack_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pStopAttack(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pStopAttack_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStopAttack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pStopAttack_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPutItemToCart(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPutItemToCart_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPutItemToCart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPutItemToCart_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPutItemToCart(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPutItemToCart_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPutItemToCart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPutItemToCart_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGetItemFromCart(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGetItemFromCart_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetItemFromCart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGetItemFromCart_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGetItemFromCart(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGetItemFromCart_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetItemFromCart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGetItemFromCart_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pRemoveOption(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pRemoveOption_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemoveOption_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pRemoveOption_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pRemoveOption(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pRemoveOption_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemoveOption_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pRemoveOption_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pChangeCart(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pChangeCart_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeCart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pChangeCart_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pChangeCart(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pChangeCart_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeCart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pChangeCart_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pStatusUp(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pStatusUp_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStatusUp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pStatusUp_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pStatusUp(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pStatusUp_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStatusUp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pStatusUp_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSkillUp(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSkillUp_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillUp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSkillUp_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSkillUp(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSkillUp_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillUp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSkillUp_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillToId(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillToId_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillToId(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillToId_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillToId_homun(struct homun_data *hd, struct map_session_data *sd, unsigned int tick, uint16 skill_id, uint16 skill_lv, int target_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillToId_homun_pre ) {
+		void (*preHookFunc) (struct homun_data *hd, struct map_session_data *sd, unsigned int *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_homun_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_homun_pre[hIndex].func;
+			preHookFunc(hd, sd, &tick, &skill_id, &skill_lv, &target_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillToId_homun(hd, sd, tick, skill_id, skill_lv, target_id);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillToId_homun_post ) {
+		void (*postHookFunc) (struct homun_data *hd, struct map_session_data *sd, unsigned int *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_homun_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_homun_post[hIndex].func;
+			postHookFunc(hd, sd, &tick, &skill_id, &skill_lv, &target_id);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillToId_mercenary(struct mercenary_data *md, struct map_session_data *sd, unsigned int tick, uint16 skill_id, uint16 skill_lv, int target_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillToId_mercenary_pre ) {
+		void (*preHookFunc) (struct mercenary_data *md, struct map_session_data *sd, unsigned int *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_mercenary_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_mercenary_pre[hIndex].func;
+			preHookFunc(md, sd, &tick, &skill_id, &skill_lv, &target_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillToId_mercenary(md, sd, tick, skill_id, skill_lv, target_id);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillToId_mercenary_post ) {
+		void (*postHookFunc) (struct mercenary_data *md, struct map_session_data *sd, unsigned int *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_mercenary_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_mercenary_post[hIndex].func;
+			postHookFunc(md, sd, &tick, &skill_id, &skill_lv, &target_id);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillToPos(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillToPos_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillToPos(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillToPos_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillToPosSub(int fd, struct map_session_data *sd, uint16 skill_lv, uint16 skill_id, short x, short y, int skillmoreinfo) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillToPosSub_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd, uint16 *skill_lv, uint16 *skill_id, short *x, short *y, int *skillmoreinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosSub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosSub_pre[hIndex].func;
+			preHookFunc(&fd, sd, &skill_lv, &skill_id, &x, &y, &skillmoreinfo);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillToPosSub(fd, sd, skill_lv, skill_id, x, y, skillmoreinfo);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillToPosSub_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd, uint16 *skill_lv, uint16 *skill_id, short *x, short *y, int *skillmoreinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosSub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosSub_post[hIndex].func;
+			postHookFunc(&fd, sd, &skill_lv, &skill_id, &x, &y, &skillmoreinfo);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillToPos_homun(struct homun_data *hd, struct map_session_data *sd, unsigned int tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillToPos_homun_pre ) {
+		void (*preHookFunc) (struct homun_data *hd, struct map_session_data *sd, unsigned int *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_homun_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_homun_pre[hIndex].func;
+			preHookFunc(hd, sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillToPos_homun(hd, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillToPos_homun_post ) {
+		void (*postHookFunc) (struct homun_data *hd, struct map_session_data *sd, unsigned int *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_homun_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_homun_post[hIndex].func;
+			postHookFunc(hd, sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillToPos_mercenary(struct mercenary_data *md, struct map_session_data *sd, unsigned int tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_pre ) {
+		void (*preHookFunc) (struct mercenary_data *md, struct map_session_data *sd, unsigned int *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_mercenary_pre[hIndex].func;
+			preHookFunc(md, sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillToPos_mercenary(md, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_post ) {
+		void (*postHookFunc) (struct mercenary_data *md, struct map_session_data *sd, unsigned int *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_mercenary_post[hIndex].func;
+			postHookFunc(md, sd, &tick, &skill_id, &skill_lv, &x, &y, &skillmoreinfo);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillToPosMoreInfo(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosMoreInfo_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillToPosMoreInfo(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosMoreInfo_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pUseSkillMap(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseSkillMap_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillMap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseSkillMap_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseSkillMap(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pUseSkillMap_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillMap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseSkillMap_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pRequestMemo(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pRequestMemo_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRequestMemo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pRequestMemo_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pRequestMemo(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pRequestMemo_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRequestMemo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pRequestMemo_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pProduceMix(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pProduceMix_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProduceMix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pProduceMix_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pProduceMix(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pProduceMix_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProduceMix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pProduceMix_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCooking(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCooking_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCooking_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCooking_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCooking(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCooking_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCooking_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCooking_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pRepairItem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pRepairItem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRepairItem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pRepairItem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pRepairItem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pRepairItem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRepairItem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pRepairItem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pWeaponRefine(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pWeaponRefine_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWeaponRefine_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pWeaponRefine_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pWeaponRefine(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pWeaponRefine_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWeaponRefine_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pWeaponRefine_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcSelectMenu(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcSelectMenu_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSelectMenu_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcSelectMenu_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcSelectMenu(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcSelectMenu_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSelectMenu_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcSelectMenu_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcNextClicked(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcNextClicked_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcNextClicked_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcNextClicked_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcNextClicked(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcNextClicked_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcNextClicked_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcNextClicked_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcAmountInput(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcAmountInput_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcAmountInput_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcAmountInput_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcAmountInput(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcAmountInput_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcAmountInput_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcAmountInput_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcStringInput(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcStringInput_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcStringInput_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcStringInput_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcStringInput(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcStringInput_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcStringInput_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcStringInput_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNpcCloseClicked(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNpcCloseClicked_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcCloseClicked_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNpcCloseClicked_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNpcCloseClicked(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNpcCloseClicked_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcCloseClicked_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNpcCloseClicked_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pItemIdentify(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pItemIdentify_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemIdentify_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pItemIdentify_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pItemIdentify(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pItemIdentify_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemIdentify_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pItemIdentify_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSelectArrow(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSelectArrow_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectArrow_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSelectArrow_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSelectArrow(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSelectArrow_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectArrow_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSelectArrow_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAutoSpell(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAutoSpell_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoSpell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAutoSpell_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAutoSpell(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAutoSpell_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoSpell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAutoSpell_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pUseCard(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pUseCard_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseCard_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pUseCard_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pUseCard(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pUseCard_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseCard_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pUseCard_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pInsertCard(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pInsertCard_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pInsertCard_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pInsertCard_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pInsertCard(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pInsertCard_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pInsertCard_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pInsertCard_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSolveCharName(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSolveCharName_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSolveCharName_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSolveCharName_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSolveCharName(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSolveCharName_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSolveCharName_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSolveCharName_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pResetChar(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pResetChar_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pResetChar_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pResetChar_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pResetChar(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pResetChar_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pResetChar_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pResetChar_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pLocalBroadcast(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pLocalBroadcast_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLocalBroadcast_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pLocalBroadcast_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pLocalBroadcast(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pLocalBroadcast_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLocalBroadcast_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pLocalBroadcast_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMoveToKafra(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMoveToKafra_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafra_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMoveToKafra_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMoveToKafra(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMoveToKafra_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafra_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMoveToKafra_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMoveFromKafra(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMoveFromKafra_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafra_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMoveFromKafra_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMoveFromKafra(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMoveFromKafra_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafra_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMoveFromKafra_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMoveToKafraFromCart(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMoveToKafraFromCart_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafraFromCart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMoveToKafraFromCart_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMoveToKafraFromCart(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMoveToKafraFromCart_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafraFromCart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMoveToKafraFromCart_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMoveFromKafraToCart(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMoveFromKafraToCart_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafraToCart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMoveFromKafraToCart_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMoveFromKafraToCart(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMoveFromKafraToCart_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafraToCart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMoveFromKafraToCart_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCloseKafra(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCloseKafra_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseKafra_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCloseKafra_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCloseKafra(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCloseKafra_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseKafra_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCloseKafra_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pStoragePassword(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pStoragePassword_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStoragePassword_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pStoragePassword_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pStoragePassword(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pStoragePassword_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStoragePassword_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pStoragePassword_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCreateParty(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCreateParty_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCreateParty_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCreateParty(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCreateParty_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCreateParty_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCreateParty2(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCreateParty2_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCreateParty2_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCreateParty2(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCreateParty2_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCreateParty2_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyInvite(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyInvite_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyInvite_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyInvite(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyInvite_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyInvite_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyInvite2(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyInvite2_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyInvite2_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyInvite2(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyInvite2_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyInvite2_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pReplyPartyInvite(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pReplyPartyInvite_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pReplyPartyInvite(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pReplyPartyInvite_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pReplyPartyInvite2(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pReplyPartyInvite2_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite2_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pReplyPartyInvite2(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pReplyPartyInvite2_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite2_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pLeaveParty(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pLeaveParty_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLeaveParty_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pLeaveParty_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pLeaveParty(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pLeaveParty_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLeaveParty_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pLeaveParty_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pRemovePartyMember(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pRemovePartyMember_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemovePartyMember_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pRemovePartyMember_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pRemovePartyMember(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pRemovePartyMember_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemovePartyMember_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pRemovePartyMember_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyChangeOption(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyChangeOption_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeOption_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyChangeOption_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyChangeOption(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyChangeOption_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeOption_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyChangeOption_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyMessage(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyMessage_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyMessage_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyMessage(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyMessage_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyMessage_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyChangeLeader(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyChangeLeader_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeLeader_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyChangeLeader_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyChangeLeader(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyChangeLeader_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeLeader_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyChangeLeader_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingRegisterReq(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingRegisterReq_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRegisterReq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingRegisterReq_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingRegisterReq(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingRegisterReq_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRegisterReq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingRegisterReq_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingSearchReq(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingSearchReq_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSearchReq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingSearchReq_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingSearchReq(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingSearchReq_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSearchReq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingSearchReq_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingDeleteReq(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingDeleteReq_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingDeleteReq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingDeleteReq_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingDeleteReq(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingDeleteReq_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingDeleteReq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingDeleteReq_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingUpdateReq(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingUpdateReq_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingUpdateReq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingUpdateReq_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingUpdateReq(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingUpdateReq_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingUpdateReq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingUpdateReq_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCloseVending(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCloseVending_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseVending_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCloseVending_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCloseVending(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCloseVending_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseVending_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCloseVending_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pVendingListReq(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pVendingListReq_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pVendingListReq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pVendingListReq_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pVendingListReq(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pVendingListReq_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pVendingListReq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pVendingListReq_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPurchaseReq(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPurchaseReq_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPurchaseReq_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPurchaseReq(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPurchaseReq_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPurchaseReq_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPurchaseReq2(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPurchaseReq2_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPurchaseReq2_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPurchaseReq2(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPurchaseReq2_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPurchaseReq2_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pOpenVending(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pOpenVending_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOpenVending_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pOpenVending_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pOpenVending(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pOpenVending_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOpenVending_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pOpenVending_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCreateGuild(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCreateGuild_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateGuild_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCreateGuild_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCreateGuild(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCreateGuild_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateGuild_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCreateGuild_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildCheckMaster(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildCheckMaster_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildCheckMaster_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildCheckMaster_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildCheckMaster(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildCheckMaster_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildCheckMaster_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildCheckMaster_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildRequestInfo(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildRequestInfo_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildRequestInfo_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildRequestInfo(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildRequestInfo_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildRequestInfo_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildChangePositionInfo(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildChangePositionInfo_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangePositionInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildChangePositionInfo_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildChangePositionInfo(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildChangePositionInfo_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangePositionInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildChangePositionInfo_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildChangeMemberPosition(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildChangeMemberPosition_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeMemberPosition_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildChangeMemberPosition_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildChangeMemberPosition(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildChangeMemberPosition_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeMemberPosition_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildChangeMemberPosition_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildRequestEmblem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildRequestEmblem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestEmblem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildRequestEmblem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildRequestEmblem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildRequestEmblem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestEmblem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildRequestEmblem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildChangeEmblem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildChangeEmblem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeEmblem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildChangeEmblem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildChangeEmblem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildChangeEmblem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeEmblem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildChangeEmblem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildChangeNotice(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildChangeNotice_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeNotice_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildChangeNotice_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildChangeNotice(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildChangeNotice_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeNotice_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildChangeNotice_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildInvite(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildInvite_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildInvite_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildInvite(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildInvite_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildInvite_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildReplyInvite(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildReplyInvite_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyInvite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildReplyInvite_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildReplyInvite(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildReplyInvite_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyInvite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildReplyInvite_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildLeave(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildLeave_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildLeave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildLeave_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildLeave(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildLeave_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildLeave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildLeave_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildExpulsion(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildExpulsion_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildExpulsion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildExpulsion_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildExpulsion(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildExpulsion_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildExpulsion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildExpulsion_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildMessage(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildMessage_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildMessage_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildMessage(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildMessage_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildMessage_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildRequestAlliance(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildRequestAlliance_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestAlliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildRequestAlliance_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildRequestAlliance(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildRequestAlliance_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestAlliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildRequestAlliance_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildReplyAlliance(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildReplyAlliance_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyAlliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildReplyAlliance_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildReplyAlliance(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildReplyAlliance_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyAlliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildReplyAlliance_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildDelAlliance(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildDelAlliance_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildDelAlliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildDelAlliance_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildDelAlliance(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildDelAlliance_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildDelAlliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildDelAlliance_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildOpposition(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildOpposition_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildOpposition_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildOpposition_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildOpposition(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildOpposition_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildOpposition_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildOpposition_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildBreak(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildBreak_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildBreak_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildBreak_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildBreak(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildBreak_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildBreak_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildBreak_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPetMenu(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPetMenu_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPetMenu_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPetMenu_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPetMenu(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPetMenu_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPetMenu_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPetMenu_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCatchPet(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCatchPet_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCatchPet_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCatchPet_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCatchPet(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCatchPet_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCatchPet_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCatchPet_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSelectEgg(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSelectEgg_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectEgg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSelectEgg_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSelectEgg(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSelectEgg_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectEgg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSelectEgg_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSendEmotion(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSendEmotion_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSendEmotion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSendEmotion_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSendEmotion(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSendEmotion_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSendEmotion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSendEmotion_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pChangePetName(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pChangePetName_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangePetName_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pChangePetName_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pChangePetName(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pChangePetName_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangePetName_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pChangePetName_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMKick(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMKick_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMKick_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMKick(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMKick_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMKick_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMKickAll(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMKickAll_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKickAll_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMKickAll_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMKickAll(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMKickAll_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKickAll_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMKickAll_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMShift(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMShift_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMShift_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMShift_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMShift(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMShift_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMShift_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMShift_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMRemove2(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMRemove2_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRemove2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMRemove2_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMRemove2(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMRemove2_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRemove2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMRemove2_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMRecall(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMRecall_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMRecall_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMRecall(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMRecall_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMRecall_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMRecall2(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMRecall2_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMRecall2_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMRecall2(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMRecall2_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMRecall2_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGM_Monster_Item(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGM_Monster_Item_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGM_Monster_Item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGM_Monster_Item_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGM_Monster_Item(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGM_Monster_Item_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGM_Monster_Item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGM_Monster_Item_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMHide(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMHide_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMHide_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMHide_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMHide(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMHide_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMHide_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMHide_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMReqNoChat(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMReqNoChat_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqNoChat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMReqNoChat_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMReqNoChat(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMReqNoChat_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqNoChat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMReqNoChat_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMRc(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMRc_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMRc_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMRc(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMRc_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMRc_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMReqAccountName(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMReqAccountName_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqAccountName_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMReqAccountName_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMReqAccountName(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMReqAccountName_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqAccountName_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMReqAccountName_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGMChangeMapType(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGMChangeMapType_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMChangeMapType_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGMChangeMapType_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGMChangeMapType(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGMChangeMapType_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMChangeMapType_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGMChangeMapType_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPMIgnore(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPMIgnore_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnore_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPMIgnore_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPMIgnore(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPMIgnore_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnore_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPMIgnore_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPMIgnoreAll(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPMIgnoreAll_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreAll_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPMIgnoreAll_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPMIgnoreAll(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPMIgnoreAll_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreAll_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPMIgnoreAll_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPMIgnoreList(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPMIgnoreList_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreList_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPMIgnoreList_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPMIgnoreList(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPMIgnoreList_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreList_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPMIgnoreList_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNoviceDoriDori(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNoviceDoriDori_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceDoriDori_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNoviceDoriDori_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNoviceDoriDori(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNoviceDoriDori_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceDoriDori_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNoviceDoriDori_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pNoviceExplosionSpirits(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pNoviceExplosionSpirits_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceExplosionSpirits_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pNoviceExplosionSpirits_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pNoviceExplosionSpirits(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pNoviceExplosionSpirits_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceExplosionSpirits_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pNoviceExplosionSpirits_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pFriendsListAdd(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pFriendsListAdd_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListAdd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pFriendsListAdd_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pFriendsListAdd(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pFriendsListAdd_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListAdd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pFriendsListAdd_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pFriendsListReply(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pFriendsListReply_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListReply_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pFriendsListReply_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pFriendsListReply(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pFriendsListReply_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListReply_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pFriendsListReply_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pFriendsListRemove(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pFriendsListRemove_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListRemove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pFriendsListRemove_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pFriendsListRemove(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pFriendsListRemove_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListRemove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pFriendsListRemove_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPVPInfo(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPVPInfo_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPVPInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPVPInfo_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPVPInfo(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPVPInfo_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPVPInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPVPInfo_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pBlacksmith(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pBlacksmith_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBlacksmith_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pBlacksmith_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pBlacksmith(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pBlacksmith_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBlacksmith_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pBlacksmith_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAlchemist(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAlchemist_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAlchemist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAlchemist_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAlchemist(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAlchemist_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAlchemist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAlchemist_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pTaekwon(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pTaekwon_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTaekwon_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pTaekwon_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pTaekwon(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pTaekwon_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTaekwon_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pTaekwon_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pRankingPk(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pRankingPk_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRankingPk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pRankingPk_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pRankingPk(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pRankingPk_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRankingPk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pRankingPk_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pFeelSaveOk(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pFeelSaveOk_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFeelSaveOk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pFeelSaveOk_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pFeelSaveOk(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pFeelSaveOk_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFeelSaveOk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pFeelSaveOk_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pChangeHomunculusName(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pChangeHomunculusName_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeHomunculusName_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pChangeHomunculusName_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pChangeHomunculusName(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pChangeHomunculusName_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeHomunculusName_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pChangeHomunculusName_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pHomMoveToMaster(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pHomMoveToMaster_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveToMaster_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pHomMoveToMaster_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pHomMoveToMaster(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pHomMoveToMaster_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveToMaster_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pHomMoveToMaster_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pHomMoveTo(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pHomMoveTo_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveTo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pHomMoveTo_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pHomMoveTo(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pHomMoveTo_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveTo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pHomMoveTo_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pHomAttack(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pHomAttack_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomAttack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pHomAttack_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pHomAttack(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pHomAttack_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomAttack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pHomAttack_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pHomMenu(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pHomMenu_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMenu_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pHomMenu_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pHomMenu(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pHomMenu_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMenu_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pHomMenu_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAutoRevive(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAutoRevive_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoRevive_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAutoRevive_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAutoRevive(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAutoRevive_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoRevive_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAutoRevive_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCheck(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCheck_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCheck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCheck_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCheck(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCheck_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCheck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCheck_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMail_refreshinbox(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMail_refreshinbox_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_refreshinbox_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMail_refreshinbox_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMail_refreshinbox(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMail_refreshinbox_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_refreshinbox_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMail_refreshinbox_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMail_read(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMail_read_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMail_read_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMail_read(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMail_read_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMail_read_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMail_getattach(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMail_getattach_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_getattach_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMail_getattach_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMail_getattach(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMail_getattach_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_getattach_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMail_getattach_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMail_delete(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMail_delete_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMail_delete_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMail_delete(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMail_delete_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMail_delete_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMail_return(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMail_return_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_return_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMail_return_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMail_return(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMail_return_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_return_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMail_return_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMail_setattach(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMail_setattach_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_setattach_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMail_setattach_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMail_setattach(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMail_setattach_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_setattach_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMail_setattach_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMail_winopen(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMail_winopen_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_winopen_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMail_winopen_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMail_winopen(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMail_winopen_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_winopen_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMail_winopen_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMail_send(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMail_send_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_send_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMail_send_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMail_send(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMail_send_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_send_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMail_send_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAuction_cancelreg(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAuction_cancelreg_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancelreg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAuction_cancelreg_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAuction_cancelreg(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAuction_cancelreg_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancelreg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAuction_cancelreg_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAuction_setitem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAuction_setitem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_setitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAuction_setitem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAuction_setitem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAuction_setitem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_setitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAuction_setitem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAuction_register(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAuction_register_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_register_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAuction_register_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAuction_register(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAuction_register_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_register_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAuction_register_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAuction_cancel(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAuction_cancel_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAuction_cancel_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAuction_cancel(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAuction_cancel_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAuction_cancel_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAuction_close(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAuction_close_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAuction_close_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAuction_close(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAuction_close_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAuction_close_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAuction_bid(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAuction_bid_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_bid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAuction_bid_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAuction_bid(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAuction_bid_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_bid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAuction_bid_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAuction_search(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAuction_search_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAuction_search_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAuction_search(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAuction_search_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAuction_search_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAuction_buysell(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAuction_buysell_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_buysell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAuction_buysell_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAuction_buysell(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAuction_buysell_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_buysell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAuction_buysell_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pcashshop_buy(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pcashshop_buy_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pcashshop_buy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pcashshop_buy_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pcashshop_buy(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pcashshop_buy_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pcashshop_buy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pcashshop_buy_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAdopt_request(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAdopt_request_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_request_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAdopt_request_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAdopt_request(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAdopt_request_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_request_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAdopt_request_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pAdopt_reply(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pAdopt_reply_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_reply_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pAdopt_reply_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pAdopt_reply(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pAdopt_reply_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_reply_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pAdopt_reply_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pViewPlayerEquip(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pViewPlayerEquip_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pViewPlayerEquip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pViewPlayerEquip_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pViewPlayerEquip(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pViewPlayerEquip_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pViewPlayerEquip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pViewPlayerEquip_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pEquipTick(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pEquipTick_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipTick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pEquipTick_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pEquipTick(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pEquipTick_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipTick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pEquipTick_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pquestStateAck(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pquestStateAck_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pquestStateAck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pquestStateAck_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pquestStateAck(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pquestStateAck_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pquestStateAck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pquestStateAck_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pmercenary_action(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pmercenary_action_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pmercenary_action_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pmercenary_action_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pmercenary_action(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pmercenary_action_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pmercenary_action_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pmercenary_action_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pBattleChat(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pBattleChat_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBattleChat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pBattleChat_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pBattleChat(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pBattleChat_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBattleChat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pBattleChat_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pLessEffect(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pLessEffect_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLessEffect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pLessEffect_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pLessEffect(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pLessEffect_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLessEffect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pLessEffect_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pItemListWindowSelected(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pItemListWindowSelected_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemListWindowSelected_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pItemListWindowSelected_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pItemListWindowSelected(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pItemListWindowSelected_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemListWindowSelected_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pItemListWindowSelected_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pReqOpenBuyingStore(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pReqOpenBuyingStore_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqOpenBuyingStore_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pReqOpenBuyingStore_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pReqOpenBuyingStore(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pReqOpenBuyingStore_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqOpenBuyingStore_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pReqOpenBuyingStore_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pReqCloseBuyingStore(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pReqCloseBuyingStore_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqCloseBuyingStore_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pReqCloseBuyingStore_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pReqCloseBuyingStore(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pReqCloseBuyingStore_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqCloseBuyingStore_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pReqCloseBuyingStore_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pReqClickBuyingStore(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pReqClickBuyingStore_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqClickBuyingStore_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pReqClickBuyingStore_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pReqClickBuyingStore(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pReqClickBuyingStore_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqClickBuyingStore_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pReqClickBuyingStore_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pReqTradeBuyingStore(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pReqTradeBuyingStore_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqTradeBuyingStore_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pReqTradeBuyingStore_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pReqTradeBuyingStore(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pReqTradeBuyingStore_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqTradeBuyingStore_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pReqTradeBuyingStore_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSearchStoreInfo(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSearchStoreInfo_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfo_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSearchStoreInfo(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSearchStoreInfo_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfo_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSearchStoreInfoNextPage(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoNextPage_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSearchStoreInfoNextPage(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoNextPage_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCloseSearchStoreInfo(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCloseSearchStoreInfo_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseSearchStoreInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCloseSearchStoreInfo_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCloseSearchStoreInfo(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCloseSearchStoreInfo_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseSearchStoreInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCloseSearchStoreInfo_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSearchStoreInfoListItemClick(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoListItemClick_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSearchStoreInfoListItemClick(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoListItemClick_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pDebug(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pDebug_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDebug_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pDebug_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pDebug(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pDebug_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDebug_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pDebug_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pSkillSelectMenu(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pSkillSelectMenu_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillSelectMenu_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pSkillSelectMenu_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pSkillSelectMenu(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pSkillSelectMenu_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillSelectMenu_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pSkillSelectMenu_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pMoveItem(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pMoveItem_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveItem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pMoveItem_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pMoveItem(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pMoveItem_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveItem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pMoveItem_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pDull(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pDull_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDull_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pDull_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pDull(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pDull_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDull_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pDull_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pBGQueueRegister(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pBGQueueRegister_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRegister_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pBGQueueRegister_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pBGQueueRegister(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pBGQueueRegister_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRegister_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pBGQueueRegister_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pBGQueueCheckState(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pBGQueueCheckState_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueCheckState_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pBGQueueCheckState_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pBGQueueCheckState(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pBGQueueCheckState_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueCheckState_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pBGQueueCheckState_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pBGQueueRevokeReq(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pBGQueueRevokeReq_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRevokeReq_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pBGQueueRevokeReq_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pBGQueueRevokeReq(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pBGQueueRevokeReq_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRevokeReq_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pBGQueueRevokeReq_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pBGQueueBattleBeginAck(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pBGQueueBattleBeginAck_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pBGQueueBattleBeginAck(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pBGQueueBattleBeginAck_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCashShopOpen(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCashShopOpen_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopOpen_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCashShopOpen_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCashShopOpen(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCashShopOpen_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopOpen_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCashShopOpen_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCashShopClose(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCashShopClose_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopClose_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCashShopClose_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCashShopClose(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCashShopClose_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopClose_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCashShopClose_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCashShopReqTab(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCashShopReqTab_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopReqTab_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCashShopReqTab_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCashShopReqTab(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCashShopReqTab_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopReqTab_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCashShopReqTab_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCashShopSchedule(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCashShopSchedule_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopSchedule_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCashShopSchedule_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCashShopSchedule(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCashShopSchedule_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopSchedule_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCashShopSchedule_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pCashShopBuy(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pCashShopBuy_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopBuy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pCashShopBuy_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pCashShopBuy(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pCashShopBuy_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopBuy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pCashShopBuy_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyTick(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyTick_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyTick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyTick_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyTick(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyTick_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyTick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyTick_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pGuildInvite2(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pGuildInvite2_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pGuildInvite2_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pGuildInvite2(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pGuildInvite2_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pGuildInvite2_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingAddFilter(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingAddFilter_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingAddFilter_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingAddFilter_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingAddFilter(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingAddFilter_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingAddFilter_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingAddFilter_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingSubFilter(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingSubFilter_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSubFilter_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingSubFilter_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingSubFilter(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingSubFilter_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSubFilter_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingSubFilter_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingReqVolunteer(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingReqVolunteer_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingReqVolunteer(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingReqVolunteer_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingRefuseVolunteer(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingRefuseVolunteer_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingRefuseVolunteer(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingRefuseVolunteer_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+void HP_clif_pPartyBookingCancelVolunteer(int fd, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_pre ) {
+		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingCancelVolunteer_pre[hIndex].func;
+			preHookFunc(&fd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.clif.pPartyBookingCancelVolunteer(fd, sd);
+	}
+	if( HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_post ) {
+		void (*postHookFunc) (int *fd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingCancelVolunteer_post[hIndex].func;
+			postHookFunc(&fd, sd);
+		}
+	}
+	return;
+}
+/* duel */
+int HP_duel_create(struct map_session_data *sd, const unsigned int maxpl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_duel_create_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const unsigned int *maxpl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_create_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &maxpl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.duel.create(sd, maxpl);
+	}
+	if( HPMHooks.count.HP_duel_create_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const unsigned int *maxpl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &maxpl);
+		}
+	}
+	return retVal___;
+}
+void HP_duel_invite(const unsigned int did, struct map_session_data *sd, struct map_session_data *target_sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_duel_invite_pre ) {
+		void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd, struct map_session_data *target_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_invite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_invite_pre[hIndex].func;
+			preHookFunc(&did, sd, target_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.duel.invite(did, sd, target_sd);
+	}
+	if( HPMHooks.count.HP_duel_invite_post ) {
+		void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd, struct map_session_data *target_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_invite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_invite_post[hIndex].func;
+			postHookFunc(&did, sd, target_sd);
+		}
+	}
+	return;
+}
+void HP_duel_accept(const unsigned int did, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_duel_accept_pre ) {
+		void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_accept_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_accept_pre[hIndex].func;
+			preHookFunc(&did, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.duel.accept(did, sd);
+	}
+	if( HPMHooks.count.HP_duel_accept_post ) {
+		void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_accept_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_accept_post[hIndex].func;
+			postHookFunc(&did, sd);
+		}
+	}
+	return;
+}
+void HP_duel_reject(const unsigned int did, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_duel_reject_pre ) {
+		void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_reject_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_reject_pre[hIndex].func;
+			preHookFunc(&did, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.duel.reject(did, sd);
+	}
+	if( HPMHooks.count.HP_duel_reject_post ) {
+		void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_reject_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_reject_post[hIndex].func;
+			postHookFunc(&did, sd);
+		}
+	}
+	return;
+}
+void HP_duel_leave(const unsigned int did, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_duel_leave_pre ) {
+		void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_leave_pre[hIndex].func;
+			preHookFunc(&did, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.duel.leave(did, sd);
+	}
+	if( HPMHooks.count.HP_duel_leave_post ) {
+		void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_leave_post[hIndex].func;
+			postHookFunc(&did, sd);
+		}
+	}
+	return;
+}
+void HP_duel_showinfo(const unsigned int did, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_duel_showinfo_pre ) {
+		void (*preHookFunc) (const unsigned int *did, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_showinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_showinfo_pre[hIndex].func;
+			preHookFunc(&did, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.duel.showinfo(did, sd);
+	}
+	if( HPMHooks.count.HP_duel_showinfo_post ) {
+		void (*postHookFunc) (const unsigned int *did, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_showinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_showinfo_post[hIndex].func;
+			postHookFunc(&did, sd);
+		}
+	}
+	return;
+}
+int HP_duel_checktime(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_duel_checktime_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_checktime_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_checktime_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.duel.checktime(sd);
+	}
+	if( HPMHooks.count.HP_duel_checktime_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_checktime_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_checktime_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_duel_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_duel_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.duel.init();
+	}
+	if( HPMHooks.count.HP_duel_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_duel_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_duel_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_duel_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.duel.final();
+	}
+	if( HPMHooks.count.HP_duel_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_duel_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+/* elemental */
+int HP_elemental_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.init();
+	}
+	if( HPMHooks.count.HP_elemental_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_elemental_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_elemental_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.elemental.final();
+	}
+	if( HPMHooks.count.HP_elemental_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+bool HP_elemental_class(int class_) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_elemental_class_pre ) {
+		bool (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_class_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_class_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.class(class_);
+	}
+	if( HPMHooks.count.HP_elemental_class_post ) {
+		bool (*postHookFunc) (bool retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_class_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_class_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+struct view_data* HP_elemental_get_viewdata(int class_) {
+	int hIndex = 0;
+	struct view_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_elemental_get_viewdata_pre ) {
+		struct view_data* (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_get_viewdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_get_viewdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.get_viewdata(class_);
+	}
+	if( HPMHooks.count.HP_elemental_get_viewdata_post ) {
+		struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_get_viewdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_get_viewdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_create(struct map_session_data *sd, int class_, unsigned int lifetime) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_create_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *class_, unsigned int *lifetime);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_create_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &class_, &lifetime);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.create(sd, class_, lifetime);
+	}
+	if( HPMHooks.count.HP_elemental_create_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *class_, unsigned int *lifetime);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &class_, &lifetime);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_data_received(struct s_elemental *ele, bool flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_data_received_pre ) {
+		int (*preHookFunc) (struct s_elemental *ele, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_data_received_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_data_received_pre[hIndex].func;
+			retVal___ = preHookFunc(ele, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.data_received(ele, flag);
+	}
+	if( HPMHooks.count.HP_elemental_data_received_post ) {
+		int (*postHookFunc) (int retVal___, struct s_elemental *ele, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_data_received_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_data_received_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ele, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_save(struct elemental_data *ed) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_save_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_save_pre[hIndex].func;
+			retVal___ = preHookFunc(ed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.save(ed);
+	}
+	if( HPMHooks.count.HP_elemental_save_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_save_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_change_mode_ack(struct elemental_data *ed, int mode) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_change_mode_ack_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed, int *mode);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_change_mode_ack_pre[hIndex].func;
+			retVal___ = preHookFunc(ed, &mode);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.change_mode_ack(ed, mode);
+	}
+	if( HPMHooks.count.HP_elemental_change_mode_ack_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed, int *mode);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_change_mode_ack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed, &mode);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_change_mode(struct elemental_data *ed, int mode) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_change_mode_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed, int *mode);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_change_mode_pre[hIndex].func;
+			retVal___ = preHookFunc(ed, &mode);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.change_mode(ed, mode);
+	}
+	if( HPMHooks.count.HP_elemental_change_mode_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed, int *mode);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_change_mode_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed, &mode);
+		}
+	}
+	return retVal___;
+}
+void HP_elemental_heal(struct elemental_data *ed, int hp, int sp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_elemental_heal_pre ) {
+		void (*preHookFunc) (struct elemental_data *ed, int *hp, int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_heal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_heal_pre[hIndex].func;
+			preHookFunc(ed, &hp, &sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.elemental.heal(ed, hp, sp);
+	}
+	if( HPMHooks.count.HP_elemental_heal_post ) {
+		void (*postHookFunc) (struct elemental_data *ed, int *hp, int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_heal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_heal_post[hIndex].func;
+			postHookFunc(ed, &hp, &sp);
+		}
+	}
+	return;
+}
+int HP_elemental_dead(struct elemental_data *ed) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_dead_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_dead_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_dead_pre[hIndex].func;
+			retVal___ = preHookFunc(ed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.dead(ed);
+	}
+	if( HPMHooks.count.HP_elemental_dead_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_dead_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_dead_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_delete(struct elemental_data *ed, int reply) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_delete_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed, int *reply);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(ed, &reply);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.delete(ed, reply);
+	}
+	if( HPMHooks.count.HP_elemental_delete_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed, int *reply);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed, &reply);
+		}
+	}
+	return retVal___;
+}
+void HP_elemental_summon_stop(struct elemental_data *ed) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_elemental_summon_stop_pre ) {
+		void (*preHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_stop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_summon_stop_pre[hIndex].func;
+			preHookFunc(ed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.elemental.summon_stop(ed);
+	}
+	if( HPMHooks.count.HP_elemental_summon_stop_post ) {
+		void (*postHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_stop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_summon_stop_post[hIndex].func;
+			postHookFunc(ed);
+		}
+	}
+	return;
+}
+int HP_elemental_get_lifetime(struct elemental_data *ed) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_get_lifetime_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_get_lifetime_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_get_lifetime_pre[hIndex].func;
+			retVal___ = preHookFunc(ed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.get_lifetime(ed);
+	}
+	if( HPMHooks.count.HP_elemental_get_lifetime_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_get_lifetime_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_get_lifetime_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_unlocktarget(struct elemental_data *ed) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_unlocktarget_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_unlocktarget_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_unlocktarget_pre[hIndex].func;
+			retVal___ = preHookFunc(ed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.unlocktarget(ed);
+	}
+	if( HPMHooks.count.HP_elemental_unlocktarget_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_unlocktarget_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_unlocktarget_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_skillnotok(uint16 skill_id, struct elemental_data *ed) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_skillnotok_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skillnotok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_skillnotok_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, ed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.skillnotok(skill_id, ed);
+	}
+	if( HPMHooks.count.HP_elemental_skillnotok_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skillnotok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_skillnotok_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, ed);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_set_target(struct map_session_data *sd, struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_set_target_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_set_target_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_set_target_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.set_target(sd, bl);
+	}
+	if( HPMHooks.count.HP_elemental_set_target_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_set_target_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_set_target_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_clean_single_effect(struct elemental_data *ed, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_clean_single_effect_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_single_effect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_clean_single_effect_pre[hIndex].func;
+			retVal___ = preHookFunc(ed, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.clean_single_effect(ed, skill_id);
+	}
+	if( HPMHooks.count.HP_elemental_clean_single_effect_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_single_effect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_clean_single_effect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_clean_effect(struct elemental_data *ed) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_clean_effect_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_effect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_clean_effect_pre[hIndex].func;
+			retVal___ = preHookFunc(ed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.clean_effect(ed);
+	}
+	if( HPMHooks.count.HP_elemental_clean_effect_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_effect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_clean_effect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_action(struct elemental_data *ed, struct block_list *bl, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_action_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_action_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_action_pre[hIndex].func;
+			retVal___ = preHookFunc(ed, bl, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.action(ed, bl, tick);
+	}
+	if( HPMHooks.count.HP_elemental_action_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_action_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_action_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed, bl, &tick);
+		}
+	}
+	return retVal___;
+}
+struct skill_condition HP_elemental_skill_get_requirements(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	struct skill_condition retVal___;
+	memset(&retVal___, '\0', sizeof(struct skill_condition));
+	if( HPMHooks.count.HP_elemental_skill_get_requirements_pre ) {
+		struct skill_condition (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skill_get_requirements_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_skill_get_requirements_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.skill_get_requirements(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_elemental_skill_get_requirements_post ) {
+		struct skill_condition (*postHookFunc) (struct skill_condition retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skill_get_requirements_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_skill_get_requirements_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_read_skilldb(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_read_skilldb_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_read_skilldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_read_skilldb_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.read_skilldb();
+	}
+	if( HPMHooks.count.HP_elemental_read_skilldb_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_read_skilldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_read_skilldb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_elemental_reload_db(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_elemental_reload_db_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_reload_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_reload_db_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.elemental.reload_db();
+	}
+	if( HPMHooks.count.HP_elemental_reload_db_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_reload_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_reload_db_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_elemental_reload_skilldb(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_elemental_reload_skilldb_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_reload_skilldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_reload_skilldb_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.elemental.reload_skilldb();
+	}
+	if( HPMHooks.count.HP_elemental_reload_skilldb_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_reload_skilldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_reload_skilldb_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_elemental_search_index(int class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_search_index_pre ) {
+		int (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_search_index_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_search_index_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.search_index(class_);
+	}
+	if( HPMHooks.count.HP_elemental_search_index_post ) {
+		int (*postHookFunc) (int retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_search_index_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_search_index_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+void HP_elemental_summon_init(struct elemental_data *ed) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_elemental_summon_init_pre ) {
+		void (*preHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_summon_init_pre[hIndex].func;
+			preHookFunc(ed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.elemental.summon_init(ed);
+	}
+	if( HPMHooks.count.HP_elemental_summon_init_post ) {
+		void (*postHookFunc) (struct elemental_data *ed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_summon_init_post[hIndex].func;
+			postHookFunc(ed);
+		}
+	}
+	return;
+}
+int HP_elemental_summon_end_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_summon_end_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_end_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_summon_end_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.summon_end_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_elemental_summon_end_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_end_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_summon_end_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_ai_sub_timer_activesearch(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_activesearch_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.elemental.ai_sub_timer_activesearch(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_activesearch_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_data *sd, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_ai_sub_timer_pre ) {
+		int (*preHookFunc) (struct elemental_data *ed, struct map_session_data *sd, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(ed, sd, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.ai_sub_timer(ed, sd, tick);
+	}
+	if( HPMHooks.count.HP_elemental_ai_sub_timer_post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed, struct map_session_data *sd, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed, sd, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_ai_sub_foreachclient_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_foreachclient_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_elemental_ai_sub_foreachclient_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.elemental.ai_sub_foreachclient(sd, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_elemental_ai_sub_foreachclient_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_foreachclient_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_elemental_ai_sub_foreachclient_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_ai_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_ai_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_ai_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.ai_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_elemental_ai_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_ai_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_elemental_read_db(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_elemental_read_db_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_read_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_elemental_read_db_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.elemental.read_db();
+	}
+	if( HPMHooks.count.HP_elemental_read_db_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_read_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_elemental_read_db_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+/* guild */
+void HP_guild_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.init();
+	}
+	if( HPMHooks.count.HP_guild_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_guild_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.final();
+	}
+	if( HPMHooks.count.HP_guild_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_guild_skill_get_max(int id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_skill_get_max_pre ) {
+		int (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skill_get_max_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_skill_get_max_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.skill_get_max(id);
+	}
+	if( HPMHooks.count.HP_guild_skill_get_max_post ) {
+		int (*postHookFunc) (int retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skill_get_max_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_skill_get_max_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_checkskill(struct guild *g, int id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_checkskill_pre ) {
+		int (*preHookFunc) (struct guild *g, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_checkskill_pre[hIndex].func;
+			retVal___ = preHookFunc(g, &id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.checkskill(g, id);
+	}
+	if( HPMHooks.count.HP_guild_checkskill_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *g, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_checkskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g, &id);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_check_skill_require(struct guild *g, int id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_check_skill_require_pre ) {
+		int (*preHookFunc) (struct guild *g, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_skill_require_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_check_skill_require_pre[hIndex].func;
+			retVal___ = preHookFunc(g, &id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.check_skill_require(g, id);
+	}
+	if( HPMHooks.count.HP_guild_check_skill_require_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *g, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_skill_require_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_check_skill_require_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g, &id);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_checkcastles(struct guild *g) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_checkcastles_pre ) {
+		int (*preHookFunc) (struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkcastles_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_checkcastles_pre[hIndex].func;
+			retVal___ = preHookFunc(g);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.checkcastles(g);
+	}
+	if( HPMHooks.count.HP_guild_checkcastles_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkcastles_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_checkcastles_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g);
+		}
+	}
+	return retVal___;
+}
+bool HP_guild_isallied(int guild_id, int guild_id2) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_guild_isallied_pre ) {
+		bool (*preHookFunc) (int *guild_id, int *guild_id2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_isallied_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_isallied_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &guild_id2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.isallied(guild_id, guild_id2);
+	}
+	if( HPMHooks.count.HP_guild_isallied_post ) {
+		bool (*postHookFunc) (bool retVal___, int *guild_id, int *guild_id2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_isallied_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_isallied_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &guild_id2);
+		}
+	}
+	return retVal___;
+}
+struct guild* HP_guild_search(int guild_id) {
+	int hIndex = 0;
+	struct guild* retVal___ = NULL;
+	if( HPMHooks.count.HP_guild_search_pre ) {
+		struct guild* (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_search_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.search(guild_id);
+	}
+	if( HPMHooks.count.HP_guild_search_post ) {
+		struct guild* (*postHookFunc) (struct guild* retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+struct guild* HP_guild_searchname(char *str) {
+	int hIndex = 0;
+	struct guild* retVal___ = NULL;
+	if( HPMHooks.count.HP_guild_searchname_pre ) {
+		struct guild* (*preHookFunc) (char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_searchname_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_searchname_pre[hIndex].func;
+			retVal___ = preHookFunc(str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.searchname(str);
+	}
+	if( HPMHooks.count.HP_guild_searchname_post ) {
+		struct guild* (*postHookFunc) (struct guild* retVal___, char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_searchname_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_searchname_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str);
+		}
+	}
+	return retVal___;
+}
+struct guild_castle* HP_guild_castle_search(int gcid) {
+	int hIndex = 0;
+	struct guild_castle* retVal___ = NULL;
+	if( HPMHooks.count.HP_guild_castle_search_pre ) {
+		struct guild_castle* (*preHookFunc) (int *gcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_castle_search_pre[hIndex].func;
+			retVal___ = preHookFunc(&gcid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.castle_search(gcid);
+	}
+	if( HPMHooks.count.HP_guild_castle_search_post ) {
+		struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, int *gcid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_castle_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &gcid);
+		}
+	}
+	return retVal___;
+}
+struct guild_castle* HP_guild_mapname2gc(const char *mapname) {
+	int hIndex = 0;
+	struct guild_castle* retVal___ = NULL;
+	if( HPMHooks.count.HP_guild_mapname2gc_pre ) {
+		struct guild_castle* (*preHookFunc) (const char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapname2gc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_mapname2gc_pre[hIndex].func;
+			retVal___ = preHookFunc(mapname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.mapname2gc(mapname);
+	}
+	if( HPMHooks.count.HP_guild_mapname2gc_post ) {
+		struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, const char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapname2gc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_mapname2gc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mapname);
+		}
+	}
+	return retVal___;
+}
+struct guild_castle* HP_guild_mapindex2gc(short mapindex) {
+	int hIndex = 0;
+	struct guild_castle* retVal___ = NULL;
+	if( HPMHooks.count.HP_guild_mapindex2gc_pre ) {
+		struct guild_castle* (*preHookFunc) (short *mapindex);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapindex2gc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_mapindex2gc_pre[hIndex].func;
+			retVal___ = preHookFunc(&mapindex);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.mapindex2gc(mapindex);
+	}
+	if( HPMHooks.count.HP_guild_mapindex2gc_post ) {
+		struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, short *mapindex);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapindex2gc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_mapindex2gc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &mapindex);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_guild_getavailablesd(struct guild *g) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_guild_getavailablesd_pre ) {
+		struct map_session_data* (*preHookFunc) (struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getavailablesd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_getavailablesd_pre[hIndex].func;
+			retVal___ = preHookFunc(g);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.getavailablesd(g);
+	}
+	if( HPMHooks.count.HP_guild_getavailablesd_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getavailablesd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_getavailablesd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_getindex(struct guild *g, int account_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_getindex_pre ) {
+		int (*preHookFunc) (struct guild *g, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getindex_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_getindex_pre[hIndex].func;
+			retVal___ = preHookFunc(g, &account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.getindex(g, account_id, char_id);
+	}
+	if( HPMHooks.count.HP_guild_getindex_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *g, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getindex_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_getindex_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_getposition(struct guild *g, struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_getposition_pre ) {
+		int (*preHookFunc) (struct guild *g, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getposition_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_getposition_pre[hIndex].func;
+			retVal___ = preHookFunc(g, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.getposition(g, sd);
+	}
+	if( HPMHooks.count.HP_guild_getposition_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *g, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getposition_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_getposition_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g, sd);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_guild_payexp(struct map_session_data *sd, unsigned int exp) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_guild_payexp_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd, unsigned int *exp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_payexp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &exp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.payexp(sd, exp);
+	}
+	if( HPMHooks.count.HP_guild_payexp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd, unsigned int *exp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_payexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &exp);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_getexp(struct map_session_data *sd, int exp) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_getexp_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *exp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_getexp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &exp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.getexp(sd, exp);
+	}
+	if( HPMHooks.count.HP_guild_getexp_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *exp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_getexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &exp);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_create(struct map_session_data *sd, const char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_create_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_create_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.create(sd, name);
+	}
+	if( HPMHooks.count.HP_guild_create_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_created(int account_id, int guild_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_created_pre ) {
+		int (*preHookFunc) (int *account_id, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_created_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_created_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.created(account_id, guild_id);
+	}
+	if( HPMHooks.count.HP_guild_created_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_created_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_created_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &guild_id);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_request_info(int guild_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_request_info_pre ) {
+		int (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_request_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_request_info_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.request_info(guild_id);
+	}
+	if( HPMHooks.count.HP_guild_request_info_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_request_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_request_info_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_recv_noinfo(int guild_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_recv_noinfo_pre ) {
+		int (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_noinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_recv_noinfo_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.recv_noinfo(guild_id);
+	}
+	if( HPMHooks.count.HP_guild_recv_noinfo_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_noinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_recv_noinfo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_recv_info(struct guild *sg) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_recv_info_pre ) {
+		int (*preHookFunc) (struct guild *sg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_recv_info_pre[hIndex].func;
+			retVal___ = preHookFunc(sg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.recv_info(sg);
+	}
+	if( HPMHooks.count.HP_guild_recv_info_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *sg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_recv_info_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sg);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_npc_request_info(int guild_id, const char *ev) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_npc_request_info_pre ) {
+		int (*preHookFunc) (int *guild_id, const char *ev);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_npc_request_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_npc_request_info_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, ev);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.npc_request_info(guild_id, ev);
+	}
+	if( HPMHooks.count.HP_guild_npc_request_info_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, const char *ev);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_npc_request_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_npc_request_info_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, ev);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_invite(struct map_session_data *sd, struct map_session_data *tsd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_invite_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_invite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_invite_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.invite(sd, tsd);
+	}
+	if( HPMHooks.count.HP_guild_invite_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_invite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_invite_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, tsd);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_reply_invite(struct map_session_data *sd, int guild_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_reply_invite_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_invite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_reply_invite_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &guild_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.reply_invite(sd, guild_id, flag);
+	}
+	if( HPMHooks.count.HP_guild_reply_invite_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_invite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_reply_invite_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &guild_id, &flag);
+		}
+	}
+	return retVal___;
+}
+void HP_guild_member_joined(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_member_joined_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_joined_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_member_joined_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.member_joined(sd);
+	}
+	if( HPMHooks.count.HP_guild_member_joined_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_joined_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_member_joined_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_guild_member_added(int guild_id, int account_id, int char_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_member_added_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_added_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_member_added_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.member_added(guild_id, account_id, char_id, flag);
+	}
+	if( HPMHooks.count.HP_guild_member_added_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_added_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_member_added_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_leave(struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_leave_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *account_id, int *char_id, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_leave_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &guild_id, &account_id, &char_id, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.leave(sd, guild_id, account_id, char_id, mes);
+	}
+	if( HPMHooks.count.HP_guild_leave_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, int *account_id, int *char_id, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_leave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &guild_id, &account_id, &char_id, mes);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_member_withdraw(int guild_id, int account_id, int char_id, int flag, const char *name, const char *mes) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_member_withdraw_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char *name, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_withdraw_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_member_withdraw_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag, name, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.member_withdraw(guild_id, account_id, char_id, flag, name, mes);
+	}
+	if( HPMHooks.count.HP_guild_member_withdraw_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *flag, const char *name, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_withdraw_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_member_withdraw_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &flag, name, mes);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_expulsion(struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_expulsion_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *account_id, int *char_id, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expulsion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_expulsion_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &guild_id, &account_id, &char_id, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.expulsion(sd, guild_id, account_id, char_id, mes);
+	}
+	if( HPMHooks.count.HP_guild_expulsion_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, int *account_id, int *char_id, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expulsion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_expulsion_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &guild_id, &account_id, &char_id, mes);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_skillup(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_skillup_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_skillup_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.skillup(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_guild_skillup_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_skillup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+void HP_guild_block_skill(struct map_session_data *sd, int time) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_block_skill_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_block_skill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_block_skill_pre[hIndex].func;
+			preHookFunc(sd, &time);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.block_skill(sd, time);
+	}
+	if( HPMHooks.count.HP_guild_block_skill_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_block_skill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_block_skill_post[hIndex].func;
+			postHookFunc(sd, &time);
+		}
+	}
+	return;
+}
+int HP_guild_reqalliance(struct map_session_data *sd, struct map_session_data *tsd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_reqalliance_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reqalliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_reqalliance_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.reqalliance(sd, tsd);
+	}
+	if( HPMHooks.count.HP_guild_reqalliance_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reqalliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_reqalliance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, tsd);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_reply_reqalliance(struct map_session_data *sd, int account_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_reply_reqalliance_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *account_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_reqalliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_reply_reqalliance_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &account_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.reply_reqalliance(sd, account_id, flag);
+	}
+	if( HPMHooks.count.HP_guild_reply_reqalliance_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *account_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_reqalliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_reply_reqalliance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &account_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_allianceack(int guild_id1, int guild_id2, int account_id1, int account_id2, int flag, const char *name1, const char *name2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_allianceack_pre ) {
+		int (*preHookFunc) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char *name1, const char *name2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_allianceack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_allianceack_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id1, &guild_id2, &account_id1, &account_id2, &flag, name1, name2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.allianceack(guild_id1, guild_id2, account_id1, account_id2, flag, name1, name2);
+	}
+	if( HPMHooks.count.HP_guild_allianceack_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag, const char *name1, const char *name2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_allianceack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_allianceack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id1, &guild_id2, &account_id1, &account_id2, &flag, name1, name2);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_delalliance(struct map_session_data *sd, int guild_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_delalliance_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_delalliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_delalliance_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &guild_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.delalliance(sd, guild_id, flag);
+	}
+	if( HPMHooks.count.HP_guild_delalliance_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_delalliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_delalliance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &guild_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_opposition(struct map_session_data *sd, struct map_session_data *tsd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_opposition_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_opposition_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_opposition_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.opposition(sd, tsd);
+	}
+	if( HPMHooks.count.HP_guild_opposition_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_opposition_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_opposition_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, tsd);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_check_alliance(int guild_id1, int guild_id2, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_check_alliance_pre ) {
+		int (*preHookFunc) (int *guild_id1, int *guild_id2, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_alliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_check_alliance_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id1, &guild_id2, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.check_alliance(guild_id1, guild_id2, flag);
+	}
+	if( HPMHooks.count.HP_guild_check_alliance_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id1, int *guild_id2, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_alliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_check_alliance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id1, &guild_id2, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_send_memberinfoshort(struct map_session_data *sd, int online) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_send_memberinfoshort_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *online);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_memberinfoshort_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_send_memberinfoshort_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &online);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.send_memberinfoshort(sd, online);
+	}
+	if( HPMHooks.count.HP_guild_send_memberinfoshort_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *online);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_memberinfoshort_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_send_memberinfoshort_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &online);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_recv_memberinfoshort(int guild_id, int account_id, int char_id, int online, int lv, int class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_recv_memberinfoshort_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_memberinfoshort_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_recv_memberinfoshort_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &online, &lv, &class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.recv_memberinfoshort(guild_id, account_id, char_id, online, lv, class_);
+	}
+	if( HPMHooks.count.HP_guild_recv_memberinfoshort_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_memberinfoshort_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_recv_memberinfoshort_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &online, &lv, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_change_memberposition(int guild_id, int account_id, int char_id, short idx) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_change_memberposition_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, short *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_memberposition_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_change_memberposition_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.change_memberposition(guild_id, account_id, char_id, idx);
+	}
+	if( HPMHooks.count.HP_guild_change_memberposition_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, short *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_memberposition_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_change_memberposition_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &idx);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_memberposition_changed(struct guild *g, int idx, int pos) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_memberposition_changed_pre ) {
+		int (*preHookFunc) (struct guild *g, int *idx, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_memberposition_changed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_memberposition_changed_pre[hIndex].func;
+			retVal___ = preHookFunc(g, &idx, &pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.memberposition_changed(g, idx, pos);
+	}
+	if( HPMHooks.count.HP_guild_memberposition_changed_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *g, int *idx, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_memberposition_changed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_memberposition_changed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g, &idx, &pos);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_change_position(int guild_id, int idx, int mode, int exp_mode, const char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_change_position_pre ) {
+		int (*preHookFunc) (int *guild_id, int *idx, int *mode, int *exp_mode, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_position_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_change_position_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &idx, &mode, &exp_mode, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.change_position(guild_id, idx, mode, exp_mode, name);
+	}
+	if( HPMHooks.count.HP_guild_change_position_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *idx, int *mode, int *exp_mode, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_position_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_change_position_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &idx, &mode, &exp_mode, name);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_position_changed(int guild_id, int idx, struct guild_position *p) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_position_changed_pre ) {
+		int (*preHookFunc) (int *guild_id, int *idx, struct guild_position *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_position_changed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_position_changed_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &idx, p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.position_changed(guild_id, idx, p);
+	}
+	if( HPMHooks.count.HP_guild_position_changed_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *idx, struct guild_position *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_position_changed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_position_changed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &idx, p);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_change_notice(struct map_session_data *sd, int guild_id, const char *mes1, const char *mes2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_change_notice_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *guild_id, const char *mes1, const char *mes2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_notice_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_change_notice_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &guild_id, mes1, mes2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.change_notice(sd, guild_id, mes1, mes2);
+	}
+	if( HPMHooks.count.HP_guild_change_notice_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *guild_id, const char *mes1, const char *mes2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_notice_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_change_notice_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &guild_id, mes1, mes2);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_notice_changed(int guild_id, const char *mes1, const char *mes2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_notice_changed_pre ) {
+		int (*preHookFunc) (int *guild_id, const char *mes1, const char *mes2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_notice_changed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_notice_changed_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, mes1, mes2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.notice_changed(guild_id, mes1, mes2);
+	}
+	if( HPMHooks.count.HP_guild_notice_changed_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, const char *mes1, const char *mes2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_notice_changed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_notice_changed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, mes1, mes2);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_change_emblem(struct map_session_data *sd, int len, const char *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_change_emblem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *len, const char *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_emblem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_change_emblem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &len, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.change_emblem(sd, len, data);
+	}
+	if( HPMHooks.count.HP_guild_change_emblem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *len, const char *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_emblem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_change_emblem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &len, data);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_emblem_changed(int len, int guild_id, int emblem_id, const char *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_emblem_changed_pre ) {
+		int (*preHookFunc) (int *len, int *guild_id, int *emblem_id, const char *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_emblem_changed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_emblem_changed_pre[hIndex].func;
+			retVal___ = preHookFunc(&len, &guild_id, &emblem_id, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.emblem_changed(len, guild_id, emblem_id, data);
+	}
+	if( HPMHooks.count.HP_guild_emblem_changed_post ) {
+		int (*postHookFunc) (int retVal___, int *len, int *guild_id, int *emblem_id, const char *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_emblem_changed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_emblem_changed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &len, &guild_id, &emblem_id, data);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_send_message(struct map_session_data *sd, const char *mes, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_send_message_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_send_message_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.send_message(sd, mes, len);
+	}
+	if( HPMHooks.count.HP_guild_send_message_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_send_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, mes, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_recv_message(int guild_id, int account_id, const char *mes, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_recv_message_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_recv_message_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.recv_message(guild_id, account_id, mes, len);
+	}
+	if( HPMHooks.count.HP_guild_recv_message_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_recv_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, mes, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_send_dot_remove(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_send_dot_remove_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_dot_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_send_dot_remove_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.send_dot_remove(sd);
+	}
+	if( HPMHooks.count.HP_guild_send_dot_remove_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_dot_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_send_dot_remove_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_skillupack(int guild_id, uint16 skill_id, int account_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_skillupack_pre ) {
+		int (*preHookFunc) (int *guild_id, uint16 *skill_id, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillupack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_skillupack_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &skill_id, &account_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.skillupack(guild_id, skill_id, account_id);
+	}
+	if( HPMHooks.count.HP_guild_skillupack_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, uint16 *skill_id, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillupack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_skillupack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &skill_id, &account_id);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_dobreak(struct map_session_data *sd, char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_dobreak_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_dobreak_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_dobreak_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.dobreak(sd, name);
+	}
+	if( HPMHooks.count.HP_guild_dobreak_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_dobreak_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_dobreak_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_broken(int guild_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_broken_pre ) {
+		int (*preHookFunc) (int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_broken_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.broken(guild_id, flag);
+	}
+	if( HPMHooks.count.HP_guild_broken_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_broken_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_gm_change(int guild_id, struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_gm_change_pre ) {
+		int (*preHookFunc) (int *guild_id, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_change_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_gm_change_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.gm_change(guild_id, sd);
+	}
+	if( HPMHooks.count.HP_guild_gm_change_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_change_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_gm_change_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_gm_changed(int guild_id, int account_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_gm_changed_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_changed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_gm_changed_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.gm_changed(guild_id, account_id, char_id);
+	}
+	if( HPMHooks.count.HP_guild_gm_changed_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_changed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_gm_changed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+void HP_guild_castle_map_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_castle_map_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_map_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_castle_map_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.castle_map_init();
+	}
+	if( HPMHooks.count.HP_guild_castle_map_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_map_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_castle_map_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_guild_castledatasave(int castle_id, int index, int value) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_castledatasave_pre ) {
+		int (*preHookFunc) (int *castle_id, int *index, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledatasave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_castledatasave_pre[hIndex].func;
+			retVal___ = preHookFunc(&castle_id, &index, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.castledatasave(castle_id, index, value);
+	}
+	if( HPMHooks.count.HP_guild_castledatasave_post ) {
+		int (*postHookFunc) (int retVal___, int *castle_id, int *index, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledatasave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_castledatasave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &castle_id, &index, &value);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_castledataloadack(int len, struct guild_castle *gc) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_castledataloadack_pre ) {
+		int (*preHookFunc) (int *len, struct guild_castle *gc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledataloadack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_castledataloadack_pre[hIndex].func;
+			retVal___ = preHookFunc(&len, gc);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.castledataloadack(len, gc);
+	}
+	if( HPMHooks.count.HP_guild_castledataloadack_post ) {
+		int (*postHookFunc) (int retVal___, int *len, struct guild_castle *gc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledataloadack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_castledataloadack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &len, gc);
+		}
+	}
+	return retVal___;
+}
+void HP_guild_castle_reconnect(int castle_id, int index, int value) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_castle_reconnect_pre ) {
+		void (*preHookFunc) (int *castle_id, int *index, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_reconnect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_castle_reconnect_pre[hIndex].func;
+			preHookFunc(&castle_id, &index, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.castle_reconnect(castle_id, index, value);
+	}
+	if( HPMHooks.count.HP_guild_castle_reconnect_post ) {
+		void (*postHookFunc) (int *castle_id, int *index, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_reconnect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_castle_reconnect_post[hIndex].func;
+			postHookFunc(&castle_id, &index, &value);
+		}
+	}
+	return;
+}
+void HP_guild_agit_start(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_agit_start_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit_start_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_agit_start_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.agit_start();
+	}
+	if( HPMHooks.count.HP_guild_agit_start_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit_start_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_agit_start_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_guild_agit_end(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_agit_end_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_agit_end_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.agit_end();
+	}
+	if( HPMHooks.count.HP_guild_agit_end_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_agit_end_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_guild_agit2_start(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_agit2_start_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit2_start_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_agit2_start_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.agit2_start();
+	}
+	if( HPMHooks.count.HP_guild_agit2_start_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit2_start_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_agit2_start_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_guild_agit2_end(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_agit2_end_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit2_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_agit2_end_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.agit2_end();
+	}
+	if( HPMHooks.count.HP_guild_agit2_end_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit2_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_agit2_end_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_guild_flag_add(struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_flag_add_pre ) {
+		void (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_flag_add_pre[hIndex].func;
+			preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.flag_add(nd);
+	}
+	if( HPMHooks.count.HP_guild_flag_add_post ) {
+		void (*postHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_flag_add_post[hIndex].func;
+			postHookFunc(nd);
+		}
+	}
+	return;
+}
+void HP_guild_flag_remove(struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_flag_remove_pre ) {
+		void (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_flag_remove_pre[hIndex].func;
+			preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.flag_remove(nd);
+	}
+	if( HPMHooks.count.HP_guild_flag_remove_post ) {
+		void (*postHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_flag_remove_post[hIndex].func;
+			postHookFunc(nd);
+		}
+	}
+	return;
+}
+void HP_guild_flags_clear(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_flags_clear_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flags_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_flags_clear_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.flags_clear();
+	}
+	if( HPMHooks.count.HP_guild_flags_clear_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flags_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_flags_clear_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_guild_aura_refresh(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_aura_refresh_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_aura_refresh_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_aura_refresh_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.aura_refresh(sd, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_guild_aura_refresh_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_aura_refresh_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_aura_refresh_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &skill_lv);
+		}
+	}
+	return;
+}
+int HP_guild_payexp_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_payexp_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_payexp_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.payexp_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_guild_payexp_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_payexp_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+TBL_PC* HP_guild_sd_check(int guild_id, int account_id, int char_id) {
+	int hIndex = 0;
+	TBL_PC* retVal___ = NULL;
+	if( HPMHooks.count.HP_guild_sd_check_pre ) {
+		TBL_PC* (*preHookFunc) (int *guild_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_sd_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_sd_check_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.sd_check(guild_id, account_id, char_id);
+	}
+	if( HPMHooks.count.HP_guild_sd_check_post ) {
+		TBL_PC* (*postHookFunc) (TBL_PC* retVal___, int *guild_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_sd_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_sd_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+bool HP_guild_read_guildskill_tree_db(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_guild_read_guildskill_tree_db_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_guildskill_tree_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_read_guildskill_tree_db_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.read_guildskill_tree_db(split, columns, current);
+	}
+	if( HPMHooks.count.HP_guild_read_guildskill_tree_db_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_guildskill_tree_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_read_guildskill_tree_db_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_guild_read_castledb(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_guild_read_castledb_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_castledb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_read_castledb_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.read_castledb(str, columns, current);
+	}
+	if( HPMHooks.count.HP_guild_read_castledb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_castledb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_read_castledb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_payexp_timer_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_payexp_timer_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_guild_payexp_timer_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.guild.payexp_timer_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_guild_payexp_timer_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_guild_payexp_timer_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_send_xy_timer_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_send_xy_timer_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_guild_send_xy_timer_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.guild.send_xy_timer_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_guild_send_xy_timer_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_guild_send_xy_timer_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_send_xy_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_send_xy_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_send_xy_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.send_xy_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_guild_send_xy_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_send_xy_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+DBData HP_guild_create_expcache(DBKey key, va_list args) {
+	int hIndex = 0;
+	DBData retVal___;
+	memset(&retVal___, '\0', sizeof(DBData));
+	if( HPMHooks.count.HP_guild_create_expcache_pre ) {
+		DBData (*preHookFunc) (DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_expcache_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_guild_create_expcache_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.guild.create_expcache(key, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_guild_create_expcache_post ) {
+		DBData (*postHookFunc) (DBData retVal___, DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_expcache_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_guild_create_expcache_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_eventlist_db_final(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_eventlist_db_final_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_eventlist_db_final_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_guild_eventlist_db_final_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.guild.eventlist_db_final(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_guild_eventlist_db_final_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_eventlist_db_final_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_guild_eventlist_db_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_expcache_db_final(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_expcache_db_final_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expcache_db_final_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_guild_expcache_db_final_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.guild.expcache_db_final(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_guild_expcache_db_final_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expcache_db_final_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_guild_expcache_db_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_castle_db_final(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_castle_db_final_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_db_final_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_guild_castle_db_final_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.guild.castle_db_final(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_guild_castle_db_final_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_db_final_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_guild_castle_db_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_broken_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_broken_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_guild_broken_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.guild.broken_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_guild_broken_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_guild_broken_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_castle_broken_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_castle_broken_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_broken_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_guild_castle_broken_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.guild.castle_broken_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_guild_castle_broken_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_broken_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_guild_castle_broken_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_guild_makemember(struct guild_member *m, struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_makemember_pre ) {
+		void (*preHookFunc) (struct guild_member *m, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_makemember_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_makemember_pre[hIndex].func;
+			preHookFunc(m, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.guild.makemember(m, sd);
+	}
+	if( HPMHooks.count.HP_guild_makemember_post ) {
+		void (*postHookFunc) (struct guild_member *m, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_makemember_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_makemember_post[hIndex].func;
+			postHookFunc(m, sd);
+		}
+	}
+	return;
+}
+int HP_guild_check_member(struct guild *g) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_check_member_pre ) {
+		int (*preHookFunc) (struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_member_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_check_member_pre[hIndex].func;
+			retVal___ = preHookFunc(g);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.check_member(g);
+	}
+	if( HPMHooks.count.HP_guild_check_member_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *g);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_member_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_check_member_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g);
+		}
+	}
+	return retVal___;
+}
+int HP_guild_get_alliance_count(struct guild *g, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_guild_get_alliance_count_pre ) {
+		int (*preHookFunc) (struct guild *g, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_get_alliance_count_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_guild_get_alliance_count_pre[hIndex].func;
+			retVal___ = preHookFunc(g, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.guild.get_alliance_count(g, flag);
+	}
+	if( HPMHooks.count.HP_guild_get_alliance_count_post ) {
+		int (*postHookFunc) (int retVal___, struct guild *g, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_get_alliance_count_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_guild_get_alliance_count_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, g, &flag);
+		}
+	}
+	return retVal___;
+}
+void HP_guild_castle_reconnect_sub(void *key, void *data, va_list ap) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_guild_castle_reconnect_sub_pre ) {
+		void (*preHookFunc) (void *key, void *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_reconnect_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_guild_castle_reconnect_sub_pre[hIndex].func;
+			preHookFunc(key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		HPMHooks.source.guild.castle_reconnect_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_guild_castle_reconnect_sub_post ) {
+		void (*postHookFunc) (void *key, void *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_reconnect_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_guild_castle_reconnect_sub_post[hIndex].func;
+			postHookFunc(key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return;
+}
+/* gstorage */
+struct guild_storage* HP_gstorage_id2storage(int guild_id) {
+	int hIndex = 0;
+	struct guild_storage* retVal___ = NULL;
+	if( HPMHooks.count.HP_gstorage_id2storage_pre ) {
+		struct guild_storage* (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_id2storage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_id2storage_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.id2storage(guild_id);
+	}
+	if( HPMHooks.count.HP_gstorage_id2storage_post ) {
+		struct guild_storage* (*postHookFunc) (struct guild_storage* retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_id2storage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_id2storage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+struct guild_storage* HP_gstorage_id2storage2(int guild_id) {
+	int hIndex = 0;
+	struct guild_storage* retVal___ = NULL;
+	if( HPMHooks.count.HP_gstorage_id2storage2_pre ) {
+		struct guild_storage* (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_id2storage2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_id2storage2_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.id2storage2(guild_id);
+	}
+	if( HPMHooks.count.HP_gstorage_id2storage2_post ) {
+		struct guild_storage* (*postHookFunc) (struct guild_storage* retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_id2storage2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_id2storage2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+void HP_gstorage_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_gstorage_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.gstorage.init();
+	}
+	if( HPMHooks.count.HP_gstorage_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_gstorage_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_gstorage_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.gstorage.final();
+	}
+	if( HPMHooks.count.HP_gstorage_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_gstorage_delete(int guild_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_delete_pre ) {
+		int (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.delete(guild_id);
+	}
+	if( HPMHooks.count.HP_gstorage_delete_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_open(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_open_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_open_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_open_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.open(sd);
+	}
+	if( HPMHooks.count.HP_gstorage_open_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_open_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_open_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_additem(struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_additem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_additem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_additem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, stor, item_data, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.additem(sd, stor, item_data, amount);
+	}
+	if( HPMHooks.count.HP_gstorage_additem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_additem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_additem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, stor, item_data, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_delitem(struct map_session_data *sd, struct guild_storage *stor, int n, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_delitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct guild_storage *stor, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_delitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, stor, &n, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.delitem(sd, stor, n, amount);
+	}
+	if( HPMHooks.count.HP_gstorage_delitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_delitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, stor, &n, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_add(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_add_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_add_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.add(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_gstorage_add_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_add_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_get(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_get_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_get_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_get_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.get(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_gstorage_get_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_get_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_get_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_addfromcart(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_addfromcart_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_addfromcart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_addfromcart_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.addfromcart(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_gstorage_addfromcart_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_addfromcart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_addfromcart_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_gettocart(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_gettocart_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_gettocart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_gettocart_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.gettocart(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_gstorage_gettocart_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_gettocart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_gettocart_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_close(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_close_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_close_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.close(sd);
+	}
+	if( HPMHooks.count.HP_gstorage_close_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_close_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_pc_quit(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_pc_quit_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_pc_quit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_pc_quit_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.pc_quit(sd, flag);
+	}
+	if( HPMHooks.count.HP_gstorage_pc_quit_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_pc_quit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_pc_quit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_save(int account_id, int guild_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_save_pre ) {
+		int (*preHookFunc) (int *account_id, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_save_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &guild_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.save(account_id, guild_id, flag);
+	}
+	if( HPMHooks.count.HP_gstorage_save_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *guild_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_save_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &guild_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_gstorage_saved(int guild_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_gstorage_saved_pre ) {
+		int (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_saved_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_gstorage_saved_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.gstorage.saved(guild_id);
+	}
+	if( HPMHooks.count.HP_gstorage_saved_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_saved_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_gstorage_saved_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+DBData HP_gstorage_create(DBKey key, va_list args) {
+	int hIndex = 0;
+	DBData retVal___;
+	memset(&retVal___, '\0', sizeof(DBData));
+	if( HPMHooks.count.HP_gstorage_create_pre ) {
+		DBData (*preHookFunc) (DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_create_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_gstorage_create_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.gstorage.create(key, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_gstorage_create_post ) {
+		DBData (*postHookFunc) (DBData retVal___, DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_create_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_gstorage_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+/* homun */
+void HP_homun_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.init();
+	}
+	if( HPMHooks.count.HP_homun_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_homun_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.final();
+	}
+	if( HPMHooks.count.HP_homun_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_homun_reload(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_reload_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_reload_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.reload();
+	}
+	if( HPMHooks.count.HP_homun_reload_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_reload_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_homun_reload_skill(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_reload_skill_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_skill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_reload_skill_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.reload_skill();
+	}
+	if( HPMHooks.count.HP_homun_reload_skill_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_skill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_reload_skill_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct view_data* HP_homun_get_viewdata(int class_) {
+	int hIndex = 0;
+	struct view_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_homun_get_viewdata_pre ) {
+		struct view_data* (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_get_viewdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_get_viewdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.get_viewdata(class_);
+	}
+	if( HPMHooks.count.HP_homun_get_viewdata_post ) {
+		struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_get_viewdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_get_viewdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+enum homun_type HP_homun_class2type(int class_) {
+	int hIndex = 0;
+	enum homun_type retVal___;
+	memset(&retVal___, '\0', sizeof(enum homun_type));
+	if( HPMHooks.count.HP_homun_class2type_pre ) {
+		enum homun_type (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_class2type_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_class2type_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.class2type(class_);
+	}
+	if( HPMHooks.count.HP_homun_class2type_post ) {
+		enum homun_type (*postHookFunc) (enum homun_type retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_class2type_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_class2type_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+void HP_homun_damaged(struct homun_data *hd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_damaged_pre ) {
+		void (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_damaged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_damaged_pre[hIndex].func;
+			preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.damaged(hd);
+	}
+	if( HPMHooks.count.HP_homun_damaged_post ) {
+		void (*postHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_damaged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_damaged_post[hIndex].func;
+			postHookFunc(hd);
+		}
+	}
+	return;
+}
+int HP_homun_dead(struct homun_data *hd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_dead_pre ) {
+		int (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_dead_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_dead_pre[hIndex].func;
+			retVal___ = preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.dead(hd);
+	}
+	if( HPMHooks.count.HP_homun_dead_post ) {
+		int (*postHookFunc) (int retVal___, struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_dead_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_dead_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_vaporize(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_vaporize_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_vaporize_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_vaporize_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.vaporize(sd, flag);
+	}
+	if( HPMHooks.count.HP_homun_vaporize_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_vaporize_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_vaporize_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_delete(struct homun_data *hd, int emote) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_delete_pre ) {
+		int (*preHookFunc) (struct homun_data *hd, int *emote);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &emote);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.delete(hd, emote);
+	}
+	if( HPMHooks.count.HP_homun_delete_post ) {
+		int (*postHookFunc) (int retVal___, struct homun_data *hd, int *emote);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &emote);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_checkskill(struct homun_data *hd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_checkskill_pre ) {
+		int (*preHookFunc) (struct homun_data *hd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_checkskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_checkskill_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.checkskill(hd, skill_id);
+	}
+	if( HPMHooks.count.HP_homun_checkskill_post ) {
+		int (*postHookFunc) (int retVal___, struct homun_data *hd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_checkskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_checkskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_calc_skilltree(struct homun_data *hd, int flag_evolve) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_calc_skilltree_pre ) {
+		int (*preHookFunc) (struct homun_data *hd, int *flag_evolve);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_calc_skilltree_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_calc_skilltree_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &flag_evolve);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.calc_skilltree(hd, flag_evolve);
+	}
+	if( HPMHooks.count.HP_homun_calc_skilltree_post ) {
+		int (*postHookFunc) (int retVal___, struct homun_data *hd, int *flag_evolve);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_calc_skilltree_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_calc_skilltree_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &flag_evolve);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_skill_tree_get_max(int id, int b_class) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_skill_tree_get_max_pre ) {
+		int (*preHookFunc) (int *id, int *b_class);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skill_tree_get_max_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_skill_tree_get_max_pre[hIndex].func;
+			retVal___ = preHookFunc(&id, &b_class);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.skill_tree_get_max(id, b_class);
+	}
+	if( HPMHooks.count.HP_homun_skill_tree_get_max_post ) {
+		int (*postHookFunc) (int retVal___, int *id, int *b_class);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skill_tree_get_max_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_skill_tree_get_max_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id, &b_class);
+		}
+	}
+	return retVal___;
+}
+void HP_homun_skillup(struct homun_data *hd, uint16 skill_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_skillup_pre ) {
+		void (*preHookFunc) (struct homun_data *hd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skillup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_skillup_pre[hIndex].func;
+			preHookFunc(hd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.skillup(hd, skill_id);
+	}
+	if( HPMHooks.count.HP_homun_skillup_post ) {
+		void (*postHookFunc) (struct homun_data *hd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skillup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_skillup_post[hIndex].func;
+			postHookFunc(hd, &skill_id);
+		}
+	}
+	return;
+}
+bool HP_homun_levelup(struct homun_data *hd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_levelup_pre ) {
+		bool (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_levelup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_levelup_pre[hIndex].func;
+			retVal___ = preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.levelup(hd);
+	}
+	if( HPMHooks.count.HP_homun_levelup_post ) {
+		bool (*postHookFunc) (bool retVal___, struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_levelup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_levelup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_change_class(struct homun_data *hd, short class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_change_class_pre ) {
+		int (*preHookFunc) (struct homun_data *hd, short *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_class_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_change_class_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.change_class(hd, class_);
+	}
+	if( HPMHooks.count.HP_homun_change_class_post ) {
+		int (*postHookFunc) (int retVal___, struct homun_data *hd, short *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_class_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_change_class_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &class_);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_evolve(struct homun_data *hd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_evolve_pre ) {
+		bool (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_evolve_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_evolve_pre[hIndex].func;
+			retVal___ = preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.evolve(hd);
+	}
+	if( HPMHooks.count.HP_homun_evolve_post ) {
+		bool (*postHookFunc) (bool retVal___, struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_evolve_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_evolve_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_mutate(struct homun_data *hd, int homun_id) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_mutate_pre ) {
+		bool (*preHookFunc) (struct homun_data *hd, int *homun_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_mutate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_mutate_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &homun_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.mutate(hd, homun_id);
+	}
+	if( HPMHooks.count.HP_homun_mutate_post ) {
+		bool (*postHookFunc) (bool retVal___, struct homun_data *hd, int *homun_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_mutate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_mutate_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &homun_id);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_gainexp(struct homun_data *hd, unsigned int exp) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_gainexp_pre ) {
+		int (*preHookFunc) (struct homun_data *hd, unsigned int *exp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_gainexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_gainexp_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &exp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.gainexp(hd, exp);
+	}
+	if( HPMHooks.count.HP_homun_gainexp_post ) {
+		int (*postHookFunc) (int retVal___, struct homun_data *hd, unsigned int *exp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_gainexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_gainexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &exp);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_homun_add_intimacy(struct homun_data *hd, unsigned int value) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_homun_add_intimacy_pre ) {
+		unsigned int (*preHookFunc) (struct homun_data *hd, unsigned int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_add_intimacy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_add_intimacy_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.add_intimacy(hd, value);
+	}
+	if( HPMHooks.count.HP_homun_add_intimacy_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct homun_data *hd, unsigned int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_add_intimacy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_add_intimacy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &value);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_homun_consume_intimacy(struct homun_data *hd, unsigned int value) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_homun_consume_intimacy_pre ) {
+		unsigned int (*preHookFunc) (struct homun_data *hd, unsigned int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_consume_intimacy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_consume_intimacy_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.consume_intimacy(hd, value);
+	}
+	if( HPMHooks.count.HP_homun_consume_intimacy_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct homun_data *hd, unsigned int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_consume_intimacy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_consume_intimacy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &value);
+		}
+	}
+	return retVal___;
+}
+void HP_homun_healed(struct homun_data *hd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_healed_pre ) {
+		void (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_healed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_healed_pre[hIndex].func;
+			preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.healed(hd);
+	}
+	if( HPMHooks.count.HP_homun_healed_post ) {
+		void (*postHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_healed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_healed_post[hIndex].func;
+			postHookFunc(hd);
+		}
+	}
+	return;
+}
+void HP_homun_save(struct homun_data *hd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_save_pre ) {
+		void (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_save_pre[hIndex].func;
+			preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.save(hd);
+	}
+	if( HPMHooks.count.HP_homun_save_post ) {
+		void (*postHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_save_post[hIndex].func;
+			postHookFunc(hd);
+		}
+	}
+	return;
+}
+unsigned char HP_homun_menu(struct map_session_data *sd, unsigned char menu_num) {
+	int hIndex = 0;
+	unsigned char retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned char));
+	if( HPMHooks.count.HP_homun_menu_pre ) {
+		unsigned char (*preHookFunc) (struct map_session_data *sd, unsigned char *menu_num);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_menu_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_menu_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &menu_num);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.menu(sd, menu_num);
+	}
+	if( HPMHooks.count.HP_homun_menu_post ) {
+		unsigned char (*postHookFunc) (unsigned char retVal___, struct map_session_data *sd, unsigned char *menu_num);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_menu_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_menu_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &menu_num);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_feed(struct map_session_data *sd, struct homun_data *hd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_feed_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_feed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_feed_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.feed(sd, hd);
+	}
+	if( HPMHooks.count.HP_homun_feed_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_feed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_feed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, hd);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_hunger_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_hunger_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_hunger_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_hunger_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.hunger_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_homun_hunger_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_hunger_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_hunger_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_homun_hunger_timer_delete(struct homun_data *hd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_hunger_timer_delete_pre ) {
+		void (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_hunger_timer_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_hunger_timer_delete_pre[hIndex].func;
+			preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.hunger_timer_delete(hd);
+	}
+	if( HPMHooks.count.HP_homun_hunger_timer_delete_post ) {
+		void (*postHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_hunger_timer_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_hunger_timer_delete_post[hIndex].func;
+			postHookFunc(hd);
+		}
+	}
+	return;
+}
+int HP_homun_change_name(struct map_session_data *sd, char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_change_name_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_change_name_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.change_name(sd, name);
+	}
+	if( HPMHooks.count.HP_homun_change_name_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_change_name_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_change_name_ack(struct map_session_data *sd, char *name, int flag) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_change_name_ack_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, char *name, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_change_name_ack_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.change_name_ack(sd, name, flag);
+	}
+	if( HPMHooks.count.HP_homun_change_name_ack_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, char *name, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_change_name_ack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_homun_db_search(int key, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_homun_db_search_pre ) {
+		int (*preHookFunc) (int *key, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_db_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_db_search_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.db_search(key, type);
+	}
+	if( HPMHooks.count.HP_homun_db_search_post ) {
+		int (*postHookFunc) (int retVal___, int *key, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_db_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_db_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, &type);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_create(struct map_session_data *sd, struct s_homunculus *hom) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_create_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, struct s_homunculus *hom);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_create_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, hom);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.create(sd, hom);
+	}
+	if( HPMHooks.count.HP_homun_create_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct s_homunculus *hom);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, hom);
+		}
+	}
+	return retVal___;
+}
+void HP_homun_init_timers(struct homun_data *hd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_init_timers_pre ) {
+		void (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_timers_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_init_timers_pre[hIndex].func;
+			preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.init_timers(hd);
+	}
+	if( HPMHooks.count.HP_homun_init_timers_post ) {
+		void (*postHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_timers_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_init_timers_post[hIndex].func;
+			postHookFunc(hd);
+		}
+	}
+	return;
+}
+bool HP_homun_call(struct map_session_data *sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_call_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_call_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_call_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.call(sd);
+	}
+	if( HPMHooks.count.HP_homun_call_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_call_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_call_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_recv_data(int account_id, struct s_homunculus *sh, int flag) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_recv_data_pre ) {
+		bool (*preHookFunc) (int *account_id, struct s_homunculus *sh, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_recv_data_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_recv_data_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, sh, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.recv_data(account_id, sh, flag);
+	}
+	if( HPMHooks.count.HP_homun_recv_data_post ) {
+		bool (*postHookFunc) (bool retVal___, int *account_id, struct s_homunculus *sh, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_recv_data_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_recv_data_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, sh, &flag);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_creation_request(struct map_session_data *sd, int class_) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_creation_request_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_creation_request_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_creation_request_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.creation_request(sd, class_);
+	}
+	if( HPMHooks.count.HP_homun_creation_request_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_creation_request_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_creation_request_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &class_);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_ressurect(struct map_session_data *sd, unsigned char per, short x, short y) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_ressurect_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, unsigned char *per, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_ressurect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_ressurect_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &per, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.ressurect(sd, per, x, y);
+	}
+	if( HPMHooks.count.HP_homun_ressurect_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned char *per, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_ressurect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_ressurect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &per, &x, &y);
+		}
+	}
+	return retVal___;
+}
+void HP_homun_revive(struct homun_data *hd, unsigned int hp, unsigned int sp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_revive_pre ) {
+		void (*preHookFunc) (struct homun_data *hd, unsigned int *hp, unsigned int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_revive_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_revive_pre[hIndex].func;
+			preHookFunc(hd, &hp, &sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.revive(hd, hp, sp);
+	}
+	if( HPMHooks.count.HP_homun_revive_post ) {
+		void (*postHookFunc) (struct homun_data *hd, unsigned int *hp, unsigned int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_revive_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_revive_post[hIndex].func;
+			postHookFunc(hd, &hp, &sp);
+		}
+	}
+	return;
+}
+void HP_homun_stat_reset(struct homun_data *hd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_stat_reset_pre ) {
+		void (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_stat_reset_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_stat_reset_pre[hIndex].func;
+			preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.stat_reset(hd);
+	}
+	if( HPMHooks.count.HP_homun_stat_reset_post ) {
+		void (*postHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_stat_reset_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_stat_reset_post[hIndex].func;
+			postHookFunc(hd);
+		}
+	}
+	return;
+}
+bool HP_homun_shuffle(struct homun_data *hd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_shuffle_pre ) {
+		bool (*preHookFunc) (struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_shuffle_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_shuffle_pre[hIndex].func;
+			retVal___ = preHookFunc(hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.shuffle(hd);
+	}
+	if( HPMHooks.count.HP_homun_shuffle_post ) {
+		bool (*postHookFunc) (bool retVal___, struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_shuffle_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_shuffle_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd);
+		}
+	}
+	return retVal___;
+}
+bool HP_homun_read_db_sub(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_read_db_sub_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_read_db_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.read_db_sub(str, columns, current);
+	}
+	if( HPMHooks.count.HP_homun_read_db_sub_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_read_db_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+void HP_homun_read_db(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_read_db_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_read_db_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.read_db();
+	}
+	if( HPMHooks.count.HP_homun_read_db_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_read_db_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+bool HP_homun_read_skill_db_sub(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_homun_read_skill_db_sub_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_skill_db_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_read_skill_db_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.homun.read_skill_db_sub(split, columns, current);
+	}
+	if( HPMHooks.count.HP_homun_read_skill_db_sub_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_skill_db_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_read_skill_db_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+void HP_homun_skill_db_read(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_skill_db_read_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skill_db_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_skill_db_read_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.skill_db_read();
+	}
+	if( HPMHooks.count.HP_homun_skill_db_read_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skill_db_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_skill_db_read_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_homun_exp_db_read(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_exp_db_read_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_exp_db_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_exp_db_read_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.exp_db_read();
+	}
+	if( HPMHooks.count.HP_homun_exp_db_read_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_exp_db_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_exp_db_read_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_homun_addspiritball(struct homun_data *hd, int max) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_addspiritball_pre ) {
+		void (*preHookFunc) (struct homun_data *hd, int *max);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_addspiritball_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_addspiritball_pre[hIndex].func;
+			preHookFunc(hd, &max);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.addspiritball(hd, max);
+	}
+	if( HPMHooks.count.HP_homun_addspiritball_post ) {
+		void (*postHookFunc) (struct homun_data *hd, int *max);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_addspiritball_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_addspiritball_post[hIndex].func;
+			postHookFunc(hd, &max);
+		}
+	}
+	return;
+}
+void HP_homun_delspiritball(struct homun_data *hd, int count, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_homun_delspiritball_pre ) {
+		void (*preHookFunc) (struct homun_data *hd, int *count, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delspiritball_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_homun_delspiritball_pre[hIndex].func;
+			preHookFunc(hd, &count, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.homun.delspiritball(hd, count, type);
+	}
+	if( HPMHooks.count.HP_homun_delspiritball_post ) {
+		void (*postHookFunc) (struct homun_data *hd, int *count, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delspiritball_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_homun_delspiritball_post[hIndex].func;
+			postHookFunc(hd, &count, &type);
+		}
+	}
+	return;
+}
+/* instance */
+void HP_instance_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_instance_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.instance.init();
+	}
+	if( HPMHooks.count.HP_instance_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_instance_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_instance_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.instance.final();
+	}
+	if( HPMHooks.count.HP_instance_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_instance_create(int party_id, const char *name, enum instance_owner_type type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_instance_create_pre ) {
+		int (*preHookFunc) (int *party_id, const char *name, enum instance_owner_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_create_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, name, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.instance.create(party_id, name, type);
+	}
+	if( HPMHooks.count.HP_instance_create_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, const char *name, enum instance_owner_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, name, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_instance_add_map(const char *name, int instance_id, bool usebasename, const char *map_name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_instance_add_map_pre ) {
+		int (*preHookFunc) (const char *name, int *instance_id, bool *usebasename, const char *map_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_add_map_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_add_map_pre[hIndex].func;
+			retVal___ = preHookFunc(name, &instance_id, &usebasename, map_name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.instance.add_map(name, instance_id, usebasename, map_name);
+	}
+	if( HPMHooks.count.HP_instance_add_map_post ) {
+		int (*postHookFunc) (int retVal___, const char *name, int *instance_id, bool *usebasename, const char *map_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_add_map_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_add_map_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, &instance_id, &usebasename, map_name);
+		}
+	}
+	return retVal___;
+}
+void HP_instance_del_map(int16 m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_instance_del_map_pre ) {
+		void (*preHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_del_map_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_del_map_pre[hIndex].func;
+			preHookFunc(&m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.instance.del_map(m);
+	}
+	if( HPMHooks.count.HP_instance_del_map_post ) {
+		void (*postHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_del_map_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_del_map_post[hIndex].func;
+			postHookFunc(&m);
+		}
+	}
+	return;
+}
+int HP_instance_map2imap(int16 m, int instance_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_instance_map2imap_pre ) {
+		int (*preHookFunc) (int16 *m, int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_map2imap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_map2imap_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, &instance_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.instance.map2imap(m, instance_id);
+	}
+	if( HPMHooks.count.HP_instance_map2imap_post ) {
+		int (*postHookFunc) (int retVal___, int16 *m, int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_map2imap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_map2imap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, &instance_id);
+		}
+	}
+	return retVal___;
+}
+int HP_instance_mapid2imapid(int16 m, int instance_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_instance_mapid2imapid_pre ) {
+		int (*preHookFunc) (int16 *m, int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_mapid2imapid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_mapid2imapid_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, &instance_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.instance.mapid2imapid(m, instance_id);
+	}
+	if( HPMHooks.count.HP_instance_mapid2imapid_post ) {
+		int (*postHookFunc) (int retVal___, int16 *m, int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_mapid2imapid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_mapid2imapid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, &instance_id);
+		}
+	}
+	return retVal___;
+}
+void HP_instance_destroy(int instance_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_instance_destroy_pre ) {
+		void (*preHookFunc) (int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_destroy_pre[hIndex].func;
+			preHookFunc(&instance_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.instance.destroy(instance_id);
+	}
+	if( HPMHooks.count.HP_instance_destroy_post ) {
+		void (*postHookFunc) (int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_destroy_post[hIndex].func;
+			postHookFunc(&instance_id);
+		}
+	}
+	return;
+}
+void HP_instance_start(int instance_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_instance_start_pre ) {
+		void (*preHookFunc) (int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_start_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_start_pre[hIndex].func;
+			preHookFunc(&instance_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.instance.start(instance_id);
+	}
+	if( HPMHooks.count.HP_instance_start_post ) {
+		void (*postHookFunc) (int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_start_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_start_post[hIndex].func;
+			postHookFunc(&instance_id);
+		}
+	}
+	return;
+}
+void HP_instance_check_idle(int instance_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_instance_check_idle_pre ) {
+		void (*preHookFunc) (int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_idle_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_check_idle_pre[hIndex].func;
+			preHookFunc(&instance_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.instance.check_idle(instance_id);
+	}
+	if( HPMHooks.count.HP_instance_check_idle_post ) {
+		void (*postHookFunc) (int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_idle_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_check_idle_post[hIndex].func;
+			postHookFunc(&instance_id);
+		}
+	}
+	return;
+}
+void HP_instance_check_kick(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_instance_check_kick_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_kick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_check_kick_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.instance.check_kick(sd);
+	}
+	if( HPMHooks.count.HP_instance_check_kick_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_kick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_check_kick_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_instance_set_timeout(int instance_id, unsigned int progress_timeout, unsigned int idle_timeout) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_instance_set_timeout_pre ) {
+		void (*preHookFunc) (int *instance_id, unsigned int *progress_timeout, unsigned int *idle_timeout);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_set_timeout_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_set_timeout_pre[hIndex].func;
+			preHookFunc(&instance_id, &progress_timeout, &idle_timeout);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.instance.set_timeout(instance_id, progress_timeout, idle_timeout);
+	}
+	if( HPMHooks.count.HP_instance_set_timeout_post ) {
+		void (*postHookFunc) (int *instance_id, unsigned int *progress_timeout, unsigned int *idle_timeout);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_set_timeout_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_set_timeout_post[hIndex].func;
+			postHookFunc(&instance_id, &progress_timeout, &idle_timeout);
+		}
+	}
+	return;
+}
+bool HP_instance_valid(int instance_id) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_instance_valid_pre ) {
+		bool (*preHookFunc) (int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_valid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_valid_pre[hIndex].func;
+			retVal___ = preHookFunc(&instance_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.instance.valid(instance_id);
+	}
+	if( HPMHooks.count.HP_instance_valid_post ) {
+		bool (*postHookFunc) (bool retVal___, int *instance_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_valid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_valid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &instance_id);
+		}
+	}
+	return retVal___;
+}
+int HP_instance_destroy_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_instance_destroy_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_instance_destroy_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.instance.destroy_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_instance_destroy_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_instance_destroy_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+/* intif */
+int HP_intif_parse(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_parse_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_parse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_parse_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.parse(fd);
+	}
+	if( HPMHooks.count.HP_intif_parse_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_parse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_parse_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_create_pet(int account_id, int char_id, short pet_type, short pet_lv, short pet_egg_id, short pet_equip, short intimate, short hungry, char rename_flag, char incuvate, char *pet_name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_create_pet_pre ) {
+		int (*preHookFunc) (int *account_id, int *char_id, short *pet_type, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incuvate, char *pet_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_pet_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_create_pet_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &char_id, &pet_type, &pet_lv, &pet_egg_id, &pet_equip, &intimate, &hungry, &rename_flag, &incuvate, pet_name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.create_pet(account_id, char_id, pet_type, pet_lv, pet_egg_id, pet_equip, intimate, hungry, rename_flag, incuvate, pet_name);
+	}
+	if( HPMHooks.count.HP_intif_create_pet_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *char_id, short *pet_type, short *pet_lv, short *pet_egg_id, short *pet_equip, short *intimate, short *hungry, char *rename_flag, char *incuvate, char *pet_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_pet_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_create_pet_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &char_id, &pet_type, &pet_lv, &pet_egg_id, &pet_equip, &intimate, &hungry, &rename_flag, &incuvate, pet_name);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_broadcast(const char *mes, int len, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_broadcast_pre ) {
+		int (*preHookFunc) (const char *mes, int *len, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_broadcast_pre[hIndex].func;
+			retVal___ = preHookFunc(mes, &len, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.broadcast(mes, len, type);
+	}
+	if( HPMHooks.count.HP_intif_broadcast_post ) {
+		int (*postHookFunc) (int retVal___, const char *mes, int *len, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_broadcast_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mes, &len, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_broadcast2(const char *mes, int len, unsigned long fontColor, short fontType, short fontSize, short fontAlign, short fontY) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_broadcast2_pre ) {
+		int (*preHookFunc) (const char *mes, int *len, unsigned long *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_broadcast2_pre[hIndex].func;
+			retVal___ = preHookFunc(mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.broadcast2(mes, len, fontColor, fontType, fontSize, fontAlign, fontY);
+	}
+	if( HPMHooks.count.HP_intif_broadcast2_post ) {
+		int (*postHookFunc) (int retVal___, const char *mes, int *len, unsigned long *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_broadcast2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mes, &len, &fontColor, &fontType, &fontSize, &fontAlign, &fontY);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_main_message(struct map_session_data *sd, const char *message) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_main_message_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_main_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_main_message_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.main_message(sd, message);
+	}
+	if( HPMHooks.count.HP_intif_main_message_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_main_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_main_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, message);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_wis_message(struct map_session_data *sd, char *nick, char *mes, int mes_len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_wis_message_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, char *nick, char *mes, int *mes_len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_wis_message_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, nick, mes, &mes_len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.wis_message(sd, nick, mes, mes_len);
+	}
+	if( HPMHooks.count.HP_intif_wis_message_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, char *nick, char *mes, int *mes_len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_wis_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, nick, mes, &mes_len);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_wis_message_to_gm(char *Wisp_name, int permission, char *mes) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_wis_message_to_gm_pre ) {
+		int (*preHookFunc) (char *Wisp_name, int *permission, char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_to_gm_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_wis_message_to_gm_pre[hIndex].func;
+			retVal___ = preHookFunc(Wisp_name, &permission, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.wis_message_to_gm(Wisp_name, permission, mes);
+	}
+	if( HPMHooks.count.HP_intif_wis_message_to_gm_post ) {
+		int (*postHookFunc) (int retVal___, char *Wisp_name, int *permission, char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_to_gm_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_wis_message_to_gm_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, Wisp_name, &permission, mes);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_saveregistry(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_saveregistry_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_saveregistry_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_saveregistry_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.saveregistry(sd, type);
+	}
+	if( HPMHooks.count.HP_intif_saveregistry_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_saveregistry_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_saveregistry_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_request_registry(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_request_registry_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_registry_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_request_registry_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.request_registry(sd, flag);
+	}
+	if( HPMHooks.count.HP_intif_request_registry_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_registry_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_request_registry_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_request_guild_storage(int account_id, int guild_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_request_guild_storage_pre ) {
+		int (*preHookFunc) (int *account_id, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_guild_storage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_request_guild_storage_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.request_guild_storage(account_id, guild_id);
+	}
+	if( HPMHooks.count.HP_intif_request_guild_storage_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_guild_storage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_request_guild_storage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &guild_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_send_guild_storage(int account_id, struct guild_storage *gstor) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_send_guild_storage_pre ) {
+		int (*preHookFunc) (int *account_id, struct guild_storage *gstor);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_send_guild_storage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_send_guild_storage_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, gstor);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.send_guild_storage(account_id, gstor);
+	}
+	if( HPMHooks.count.HP_intif_send_guild_storage_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, struct guild_storage *gstor);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_send_guild_storage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_send_guild_storage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, gstor);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_create_party(struct party_member *member, char *name, int item, int item2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_create_party_pre ) {
+		int (*preHookFunc) (struct party_member *member, char *name, int *item, int *item2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_party_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_create_party_pre[hIndex].func;
+			retVal___ = preHookFunc(member, name, &item, &item2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.create_party(member, name, item, item2);
+	}
+	if( HPMHooks.count.HP_intif_create_party_post ) {
+		int (*postHookFunc) (int retVal___, struct party_member *member, char *name, int *item, int *item2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_party_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_create_party_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, member, name, &item, &item2);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_request_partyinfo(int party_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_request_partyinfo_pre ) {
+		int (*preHookFunc) (int *party_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_partyinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_request_partyinfo_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.request_partyinfo(party_id, char_id);
+	}
+	if( HPMHooks.count.HP_intif_request_partyinfo_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_partyinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_request_partyinfo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_party_addmember(int party_id, struct party_member *member) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_party_addmember_pre ) {
+		int (*preHookFunc) (int *party_id, struct party_member *member);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_addmember_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_party_addmember_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, member);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.party_addmember(party_id, member);
+	}
+	if( HPMHooks.count.HP_intif_party_addmember_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, struct party_member *member);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_addmember_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_party_addmember_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, member);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_party_changeoption(int party_id, int account_id, int exp, int item) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_party_changeoption_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, int *exp, int *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changeoption_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_party_changeoption_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, &exp, &item);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.party_changeoption(party_id, account_id, exp, item);
+	}
+	if( HPMHooks.count.HP_intif_party_changeoption_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *exp, int *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changeoption_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_party_changeoption_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, &exp, &item);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_party_leave(int party_id, int account_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_party_leave_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_party_leave_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.party_leave(party_id, account_id, char_id);
+	}
+	if( HPMHooks.count.HP_intif_party_leave_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_party_leave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_party_changemap(struct map_session_data *sd, int online) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_party_changemap_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *online);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changemap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_party_changemap_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &online);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.party_changemap(sd, online);
+	}
+	if( HPMHooks.count.HP_intif_party_changemap_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *online);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changemap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_party_changemap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &online);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_break_party(int party_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_break_party_pre ) {
+		int (*preHookFunc) (int *party_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_break_party_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_break_party_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.break_party(party_id);
+	}
+	if( HPMHooks.count.HP_intif_break_party_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_break_party_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_break_party_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_party_message(int party_id, int account_id, const char *mes, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_party_message_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_party_message_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.party_message(party_id, account_id, mes, len);
+	}
+	if( HPMHooks.count.HP_intif_party_message_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_party_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, mes, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_party_leaderchange(int party_id, int account_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_party_leaderchange_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_leaderchange_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_party_leaderchange_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.party_leaderchange(party_id, account_id, char_id);
+	}
+	if( HPMHooks.count.HP_intif_party_leaderchange_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_leaderchange_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_party_leaderchange_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_create(const char *name, const struct guild_member *master) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_create_pre ) {
+		int (*preHookFunc) (const char *name, const struct guild_member *master);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_create_pre[hIndex].func;
+			retVal___ = preHookFunc(name, master);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_create(name, master);
+	}
+	if( HPMHooks.count.HP_intif_guild_create_post ) {
+		int (*postHookFunc) (int retVal___, const char *name, const struct guild_member *master);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, master);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_request_info(int guild_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_request_info_pre ) {
+		int (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_request_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_request_info_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_request_info(guild_id);
+	}
+	if( HPMHooks.count.HP_intif_guild_request_info_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_request_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_request_info_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_addmember(int guild_id, struct guild_member *m) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_addmember_pre ) {
+		int (*preHookFunc) (int *guild_id, struct guild_member *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_addmember_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_addmember_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_addmember(guild_id, m);
+	}
+	if( HPMHooks.count.HP_intif_guild_addmember_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, struct guild_member *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_addmember_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_addmember_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, m);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_leave(int guild_id, int account_id, int char_id, int flag, const char *mes) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_leave_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_leave_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &flag, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_leave(guild_id, account_id, char_id, flag, mes);
+	}
+	if( HPMHooks.count.HP_intif_guild_leave_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *flag, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_leave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &flag, mes);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_memberinfoshort(int guild_id, int account_id, int char_id, int online, int lv, int class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_memberinfoshort_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_memberinfoshort_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_memberinfoshort_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &online, &lv, &class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_memberinfoshort(guild_id, account_id, char_id, online, lv, class_);
+	}
+	if( HPMHooks.count.HP_intif_guild_memberinfoshort_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *online, int *lv, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_memberinfoshort_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_memberinfoshort_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &online, &lv, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_break(int guild_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_break_pre ) {
+		int (*preHookFunc) (int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_break_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_break_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_break(guild_id);
+	}
+	if( HPMHooks.count.HP_intif_guild_break_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_break_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_break_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_message(int guild_id, int account_id, const char *mes, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_message_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_message_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_message(guild_id, account_id, mes, len);
+	}
+	if( HPMHooks.count.HP_intif_guild_message_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, mes, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_change_gm(int guild_id, const char *name, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_change_gm_pre ) {
+		int (*preHookFunc) (int *guild_id, const char *name, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_gm_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_change_gm_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, name, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_change_gm(guild_id, name, len);
+	}
+	if( HPMHooks.count.HP_intif_guild_change_gm_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, const char *name, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_gm_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_change_gm_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, name, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_change_basicinfo(int guild_id, int type, const void *data, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_change_basicinfo_pre ) {
+		int (*preHookFunc) (int *guild_id, int *type, const void *data, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_basicinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_change_basicinfo_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &type, data, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_change_basicinfo(guild_id, type, data, len);
+	}
+	if( HPMHooks.count.HP_intif_guild_change_basicinfo_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *type, const void *data, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_basicinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_change_basicinfo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &type, data, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_change_memberinfo(int guild_id, int account_id, int char_id, int type, const void *data, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_change_memberinfo_pre ) {
+		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *type, const void *data, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_memberinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_change_memberinfo_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &account_id, &char_id, &type, data, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_change_memberinfo(guild_id, account_id, char_id, type, data, len);
+	}
+	if( HPMHooks.count.HP_intif_guild_change_memberinfo_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *account_id, int *char_id, int *type, const void *data, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_memberinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_change_memberinfo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &account_id, &char_id, &type, data, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_position(int guild_id, int idx, struct guild_position *p) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_position_pre ) {
+		int (*preHookFunc) (int *guild_id, int *idx, struct guild_position *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_position_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_position_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &idx, p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_position(guild_id, idx, p);
+	}
+	if( HPMHooks.count.HP_intif_guild_position_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *idx, struct guild_position *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_position_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_position_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &idx, p);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_skillup(int guild_id, uint16 skill_id, int account_id, int max) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_skillup_pre ) {
+		int (*preHookFunc) (int *guild_id, uint16 *skill_id, int *account_id, int *max);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_skillup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_skillup_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &skill_id, &account_id, &max);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_skillup(guild_id, skill_id, account_id, max);
+	}
+	if( HPMHooks.count.HP_intif_guild_skillup_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, uint16 *skill_id, int *account_id, int *max);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_skillup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_skillup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &skill_id, &account_id, &max);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_alliance(int guild_id1, int guild_id2, int account_id1, int account_id2, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_alliance_pre ) {
+		int (*preHookFunc) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_alliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_alliance_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id1, &guild_id2, &account_id1, &account_id2, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_alliance(guild_id1, guild_id2, account_id1, account_id2, flag);
+	}
+	if( HPMHooks.count.HP_intif_guild_alliance_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_alliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_alliance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id1, &guild_id2, &account_id1, &account_id2, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_notice(int guild_id, const char *mes1, const char *mes2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_notice_pre ) {
+		int (*preHookFunc) (int *guild_id, const char *mes1, const char *mes2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_notice_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_notice_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, mes1, mes2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_notice(guild_id, mes1, mes2);
+	}
+	if( HPMHooks.count.HP_intif_guild_notice_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, const char *mes1, const char *mes2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_notice_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_notice_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, mes1, mes2);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_emblem(int guild_id, int len, const char *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_emblem_pre ) {
+		int (*preHookFunc) (int *guild_id, int *len, const char *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_emblem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_emblem_pre[hIndex].func;
+			retVal___ = preHookFunc(&guild_id, &len, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_emblem(guild_id, len, data);
+	}
+	if( HPMHooks.count.HP_intif_guild_emblem_post ) {
+		int (*postHookFunc) (int retVal___, int *guild_id, int *len, const char *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_emblem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_emblem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &guild_id, &len, data);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_castle_dataload(int num, int *castle_ids) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_castle_dataload_pre ) {
+		int (*preHookFunc) (int *num, int *castle_ids);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_dataload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_castle_dataload_pre[hIndex].func;
+			retVal___ = preHookFunc(&num, castle_ids);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_castle_dataload(num, castle_ids);
+	}
+	if( HPMHooks.count.HP_intif_guild_castle_dataload_post ) {
+		int (*postHookFunc) (int retVal___, int *num, int *castle_ids);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_dataload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_castle_dataload_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &num, castle_ids);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_guild_castle_datasave(int castle_id, int index, int value) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_guild_castle_datasave_pre ) {
+		int (*preHookFunc) (int *castle_id, int *index, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_datasave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_guild_castle_datasave_pre[hIndex].func;
+			retVal___ = preHookFunc(&castle_id, &index, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.guild_castle_datasave(castle_id, index, value);
+	}
+	if( HPMHooks.count.HP_intif_guild_castle_datasave_post ) {
+		int (*postHookFunc) (int retVal___, int *castle_id, int *index, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_datasave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_guild_castle_datasave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &castle_id, &index, &value);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_request_petdata(int account_id, int char_id, int pet_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_request_petdata_pre ) {
+		int (*preHookFunc) (int *account_id, int *char_id, int *pet_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_petdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_request_petdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &char_id, &pet_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.request_petdata(account_id, char_id, pet_id);
+	}
+	if( HPMHooks.count.HP_intif_request_petdata_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *char_id, int *pet_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_petdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_request_petdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &char_id, &pet_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_save_petdata(int account_id, struct s_pet *p) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_save_petdata_pre ) {
+		int (*preHookFunc) (int *account_id, struct s_pet *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_save_petdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_save_petdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.save_petdata(account_id, p);
+	}
+	if( HPMHooks.count.HP_intif_save_petdata_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, struct s_pet *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_save_petdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_save_petdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, p);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_delete_petdata(int pet_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_delete_petdata_pre ) {
+		int (*preHookFunc) (int *pet_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_delete_petdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_delete_petdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&pet_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.delete_petdata(pet_id);
+	}
+	if( HPMHooks.count.HP_intif_delete_petdata_post ) {
+		int (*postHookFunc) (int retVal___, int *pet_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_delete_petdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_delete_petdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &pet_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_rename(struct map_session_data *sd, int type, char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_rename_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_rename_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_rename_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.rename(sd, type, name);
+	}
+	if( HPMHooks.count.HP_intif_rename_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_rename_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_rename_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, name);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_homunculus_create(int account_id, struct s_homunculus *sh) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_homunculus_create_pre ) {
+		int (*preHookFunc) (int *account_id, struct s_homunculus *sh);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_homunculus_create_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, sh);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.homunculus_create(account_id, sh);
+	}
+	if( HPMHooks.count.HP_intif_homunculus_create_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, struct s_homunculus *sh);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_homunculus_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, sh);
+		}
+	}
+	return retVal___;
+}
+bool HP_intif_homunculus_requestload(int account_id, int homun_id) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_intif_homunculus_requestload_pre ) {
+		bool (*preHookFunc) (int *account_id, int *homun_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_homunculus_requestload_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &homun_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.homunculus_requestload(account_id, homun_id);
+	}
+	if( HPMHooks.count.HP_intif_homunculus_requestload_post ) {
+		bool (*postHookFunc) (bool retVal___, int *account_id, int *homun_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_homunculus_requestload_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &homun_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_homunculus_requestsave(int account_id, struct s_homunculus *sh) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_homunculus_requestsave_pre ) {
+		int (*preHookFunc) (int *account_id, struct s_homunculus *sh);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestsave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_homunculus_requestsave_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, sh);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.homunculus_requestsave(account_id, sh);
+	}
+	if( HPMHooks.count.HP_intif_homunculus_requestsave_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, struct s_homunculus *sh);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestsave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_homunculus_requestsave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, sh);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_homunculus_requestdelete(int homun_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_homunculus_requestdelete_pre ) {
+		int (*preHookFunc) (int *homun_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestdelete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_homunculus_requestdelete_pre[hIndex].func;
+			retVal___ = preHookFunc(&homun_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.homunculus_requestdelete(homun_id);
+	}
+	if( HPMHooks.count.HP_intif_homunculus_requestdelete_post ) {
+		int (*postHookFunc) (int retVal___, int *homun_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestdelete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_homunculus_requestdelete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &homun_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_request_questlog(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_request_questlog_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_questlog_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_request_questlog_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.request_questlog(sd);
+	}
+	if( HPMHooks.count.HP_intif_request_questlog_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_questlog_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_request_questlog_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_quest_save(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_quest_save_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_quest_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_quest_save_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.quest_save(sd);
+	}
+	if( HPMHooks.count.HP_intif_quest_save_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_quest_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_quest_save_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_mercenary_create(struct s_mercenary *merc) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_mercenary_create_pre ) {
+		int (*preHookFunc) (struct s_mercenary *merc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_mercenary_create_pre[hIndex].func;
+			retVal___ = preHookFunc(merc);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.mercenary_create(merc);
+	}
+	if( HPMHooks.count.HP_intif_mercenary_create_post ) {
+		int (*postHookFunc) (int retVal___, struct s_mercenary *merc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_mercenary_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, merc);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_mercenary_request(int merc_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_mercenary_request_pre ) {
+		int (*preHookFunc) (int *merc_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_request_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_mercenary_request_pre[hIndex].func;
+			retVal___ = preHookFunc(&merc_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.mercenary_request(merc_id, char_id);
+	}
+	if( HPMHooks.count.HP_intif_mercenary_request_post ) {
+		int (*postHookFunc) (int retVal___, int *merc_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_request_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_mercenary_request_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &merc_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_mercenary_delete(int merc_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_mercenary_delete_pre ) {
+		int (*preHookFunc) (int *merc_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_mercenary_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(&merc_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.mercenary_delete(merc_id);
+	}
+	if( HPMHooks.count.HP_intif_mercenary_delete_post ) {
+		int (*postHookFunc) (int retVal___, int *merc_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_mercenary_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &merc_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_mercenary_save(struct s_mercenary *merc) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_mercenary_save_pre ) {
+		int (*preHookFunc) (struct s_mercenary *merc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_mercenary_save_pre[hIndex].func;
+			retVal___ = preHookFunc(merc);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.mercenary_save(merc);
+	}
+	if( HPMHooks.count.HP_intif_mercenary_save_post ) {
+		int (*postHookFunc) (int retVal___, struct s_mercenary *merc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_mercenary_save_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, merc);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Mail_requestinbox(int char_id, unsigned char flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Mail_requestinbox_pre ) {
+		int (*preHookFunc) (int *char_id, unsigned char *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_requestinbox_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Mail_requestinbox_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Mail_requestinbox(char_id, flag);
+	}
+	if( HPMHooks.count.HP_intif_Mail_requestinbox_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, unsigned char *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_requestinbox_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Mail_requestinbox_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Mail_read(int mail_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Mail_read_pre ) {
+		int (*preHookFunc) (int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Mail_read_pre[hIndex].func;
+			retVal___ = preHookFunc(&mail_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Mail_read(mail_id);
+	}
+	if( HPMHooks.count.HP_intif_Mail_read_post ) {
+		int (*postHookFunc) (int retVal___, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Mail_read_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &mail_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Mail_getattach(int char_id, int mail_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Mail_getattach_pre ) {
+		int (*preHookFunc) (int *char_id, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_getattach_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Mail_getattach_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &mail_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Mail_getattach(char_id, mail_id);
+	}
+	if( HPMHooks.count.HP_intif_Mail_getattach_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_getattach_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Mail_getattach_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &mail_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Mail_delete(int char_id, int mail_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Mail_delete_pre ) {
+		int (*preHookFunc) (int *char_id, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Mail_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &mail_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Mail_delete(char_id, mail_id);
+	}
+	if( HPMHooks.count.HP_intif_Mail_delete_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Mail_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &mail_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Mail_return(int char_id, int mail_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Mail_return_pre ) {
+		int (*preHookFunc) (int *char_id, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_return_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Mail_return_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &mail_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Mail_return(char_id, mail_id);
+	}
+	if( HPMHooks.count.HP_intif_Mail_return_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, int *mail_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_return_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Mail_return_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &mail_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Mail_send(int account_id, struct mail_message *msg) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Mail_send_pre ) {
+		int (*preHookFunc) (int *account_id, struct mail_message *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_send_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Mail_send_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Mail_send(account_id, msg);
+	}
+	if( HPMHooks.count.HP_intif_Mail_send_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, struct mail_message *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_send_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Mail_send_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, msg);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Auction_requestlist(int char_id, short type, int price, const char *searchtext, short page) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Auction_requestlist_pre ) {
+		int (*preHookFunc) (int *char_id, short *type, int *price, const char *searchtext, short *page);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_requestlist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Auction_requestlist_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &type, &price, searchtext, &page);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Auction_requestlist(char_id, type, price, searchtext, page);
+	}
+	if( HPMHooks.count.HP_intif_Auction_requestlist_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, short *type, int *price, const char *searchtext, short *page);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_requestlist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Auction_requestlist_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &type, &price, searchtext, &page);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Auction_register(struct auction_data *auction) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Auction_register_pre ) {
+		int (*preHookFunc) (struct auction_data *auction);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_register_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Auction_register_pre[hIndex].func;
+			retVal___ = preHookFunc(auction);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Auction_register(auction);
+	}
+	if( HPMHooks.count.HP_intif_Auction_register_post ) {
+		int (*postHookFunc) (int retVal___, struct auction_data *auction);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_register_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Auction_register_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, auction);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Auction_cancel(int char_id, unsigned int auction_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Auction_cancel_pre ) {
+		int (*preHookFunc) (int *char_id, unsigned int *auction_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_cancel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Auction_cancel_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &auction_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Auction_cancel(char_id, auction_id);
+	}
+	if( HPMHooks.count.HP_intif_Auction_cancel_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, unsigned int *auction_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_cancel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Auction_cancel_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &auction_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Auction_close(int char_id, unsigned int auction_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Auction_close_pre ) {
+		int (*preHookFunc) (int *char_id, unsigned int *auction_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Auction_close_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &auction_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Auction_close(char_id, auction_id);
+	}
+	if( HPMHooks.count.HP_intif_Auction_close_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, unsigned int *auction_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Auction_close_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &auction_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_Auction_bid(int char_id, const char *name, unsigned int auction_id, int bid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_Auction_bid_pre ) {
+		int (*preHookFunc) (int *char_id, const char *name, unsigned int *auction_id, int *bid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_bid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_Auction_bid_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, name, &auction_id, &bid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.Auction_bid(char_id, name, auction_id, bid);
+	}
+	if( HPMHooks.count.HP_intif_Auction_bid_post ) {
+		int (*postHookFunc) (int retVal___, int *char_id, const char *name, unsigned int *auction_id, int *bid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_bid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_Auction_bid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, name, &auction_id, &bid);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_elemental_create(struct s_elemental *ele) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_elemental_create_pre ) {
+		int (*preHookFunc) (struct s_elemental *ele);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_elemental_create_pre[hIndex].func;
+			retVal___ = preHookFunc(ele);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.elemental_create(ele);
+	}
+	if( HPMHooks.count.HP_intif_elemental_create_post ) {
+		int (*postHookFunc) (int retVal___, struct s_elemental *ele);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_elemental_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ele);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_elemental_request(int ele_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_elemental_request_pre ) {
+		int (*preHookFunc) (int *ele_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_request_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_elemental_request_pre[hIndex].func;
+			retVal___ = preHookFunc(&ele_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.elemental_request(ele_id, char_id);
+	}
+	if( HPMHooks.count.HP_intif_elemental_request_post ) {
+		int (*postHookFunc) (int retVal___, int *ele_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_request_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_elemental_request_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &ele_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_elemental_delete(int ele_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_elemental_delete_pre ) {
+		int (*preHookFunc) (int *ele_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_elemental_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(&ele_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.elemental_delete(ele_id);
+	}
+	if( HPMHooks.count.HP_intif_elemental_delete_post ) {
+		int (*postHookFunc) (int retVal___, int *ele_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_elemental_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &ele_id);
+		}
+	}
+	return retVal___;
+}
+int HP_intif_elemental_save(struct s_elemental *ele) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_elemental_save_pre ) {
+		int (*preHookFunc) (struct s_elemental *ele);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_elemental_save_pre[hIndex].func;
+			retVal___ = preHookFunc(ele);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.elemental_save(ele);
+	}
+	if( HPMHooks.count.HP_intif_elemental_save_post ) {
+		int (*postHookFunc) (int retVal___, struct s_elemental *ele);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_elemental_save_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ele);
+		}
+	}
+	return retVal___;
+}
+void HP_intif_request_accinfo(int u_fd, int aid, int group_lv, char *query) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_request_accinfo_pre ) {
+		void (*preHookFunc) (int *u_fd, int *aid, int *group_lv, char *query);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_accinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_request_accinfo_pre[hIndex].func;
+			preHookFunc(&u_fd, &aid, &group_lv, query);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.request_accinfo(u_fd, aid, group_lv, query);
+	}
+	if( HPMHooks.count.HP_intif_request_accinfo_post ) {
+		void (*postHookFunc) (int *u_fd, int *aid, int *group_lv, char *query);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_accinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_request_accinfo_post[hIndex].func;
+			postHookFunc(&u_fd, &aid, &group_lv, query);
+		}
+	}
+	return;
+}
+int HP_intif_CheckForCharServer(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_CheckForCharServer_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_CheckForCharServer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_CheckForCharServer_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.intif.CheckForCharServer();
+	}
+	if( HPMHooks.count.HP_intif_CheckForCharServer_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_CheckForCharServer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_CheckForCharServer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_intif_pWisMessage(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pWisMessage_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pWisMessage_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pWisMessage(fd);
+	}
+	if( HPMHooks.count.HP_intif_pWisMessage_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pWisMessage_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pWisEnd(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pWisEnd_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisEnd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pWisEnd_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pWisEnd(fd);
+	}
+	if( HPMHooks.count.HP_intif_pWisEnd_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisEnd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pWisEnd_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+int HP_intif_pWisToGM_sub(struct map_session_data *sd, va_list va) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_intif_pWisToGM_sub_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list va);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_sub_pre; hIndex++ ) {
+			va_list va___copy; va_copy(va___copy, va);
+			preHookFunc = HPMHooks.list.HP_intif_pWisToGM_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, va___copy);
+			va_end(va___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list va___copy; va_copy(va___copy, va);
+		retVal___ = HPMHooks.source.intif.pWisToGM_sub(sd, va___copy);
+		va_end(va___copy);
+	}
+	if( HPMHooks.count.HP_intif_pWisToGM_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list va);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_sub_post; hIndex++ ) {
+			va_list va___copy; va_copy(va___copy, va);
+			postHookFunc = HPMHooks.list.HP_intif_pWisToGM_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, va___copy);
+			va_end(va___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_intif_pWisToGM(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pWisToGM_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pWisToGM_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pWisToGM(fd);
+	}
+	if( HPMHooks.count.HP_intif_pWisToGM_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pWisToGM_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pRegisters(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pRegisters_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRegisters_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pRegisters_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pRegisters(fd);
+	}
+	if( HPMHooks.count.HP_intif_pRegisters_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRegisters_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pRegisters_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pChangeNameOk(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pChangeNameOk_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pChangeNameOk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pChangeNameOk_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pChangeNameOk(fd);
+	}
+	if( HPMHooks.count.HP_intif_pChangeNameOk_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pChangeNameOk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pChangeNameOk_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMessageToFD(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMessageToFD_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMessageToFD_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMessageToFD_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMessageToFD(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMessageToFD_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMessageToFD_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMessageToFD_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pLoadGuildStorage(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pLoadGuildStorage_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pLoadGuildStorage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pLoadGuildStorage_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pLoadGuildStorage(fd);
+	}
+	if( HPMHooks.count.HP_intif_pLoadGuildStorage_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pLoadGuildStorage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pLoadGuildStorage_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pSaveGuildStorage(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pSaveGuildStorage_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveGuildStorage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pSaveGuildStorage_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pSaveGuildStorage(fd);
+	}
+	if( HPMHooks.count.HP_intif_pSaveGuildStorage_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveGuildStorage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pSaveGuildStorage_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pPartyCreated(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pPartyCreated_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyCreated_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pPartyCreated_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pPartyCreated(fd);
+	}
+	if( HPMHooks.count.HP_intif_pPartyCreated_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyCreated_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pPartyCreated_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pPartyInfo(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pPartyInfo_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pPartyInfo_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pPartyInfo(fd);
+	}
+	if( HPMHooks.count.HP_intif_pPartyInfo_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pPartyInfo_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pPartyMemberAdded(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pPartyMemberAdded_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberAdded_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pPartyMemberAdded_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pPartyMemberAdded(fd);
+	}
+	if( HPMHooks.count.HP_intif_pPartyMemberAdded_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberAdded_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pPartyMemberAdded_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pPartyOptionChanged(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pPartyOptionChanged_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyOptionChanged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pPartyOptionChanged_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pPartyOptionChanged(fd);
+	}
+	if( HPMHooks.count.HP_intif_pPartyOptionChanged_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyOptionChanged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pPartyOptionChanged_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pPartyMemberWithdraw(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pPartyMemberWithdraw_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberWithdraw_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pPartyMemberWithdraw_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pPartyMemberWithdraw(fd);
+	}
+	if( HPMHooks.count.HP_intif_pPartyMemberWithdraw_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberWithdraw_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pPartyMemberWithdraw_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pPartyMove(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pPartyMove_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pPartyMove_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pPartyMove(fd);
+	}
+	if( HPMHooks.count.HP_intif_pPartyMove_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pPartyMove_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pPartyBroken(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pPartyBroken_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyBroken_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pPartyBroken_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pPartyBroken(fd);
+	}
+	if( HPMHooks.count.HP_intif_pPartyBroken_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyBroken_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pPartyBroken_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pPartyMessage(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pPartyMessage_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pPartyMessage_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pPartyMessage(fd);
+	}
+	if( HPMHooks.count.HP_intif_pPartyMessage_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pPartyMessage_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildCreated(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildCreated_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCreated_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildCreated_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildCreated(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildCreated_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCreated_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildCreated_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildInfo(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildInfo_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildInfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildInfo_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildInfo(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildInfo_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildInfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildInfo_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildMemberAdded(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildMemberAdded_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberAdded_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildMemberAdded_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildMemberAdded(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildMemberAdded_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberAdded_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildMemberAdded_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildMemberWithdraw(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildMemberWithdraw_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberWithdraw_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildMemberWithdraw_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildMemberWithdraw(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildMemberWithdraw_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberWithdraw_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildMemberWithdraw_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildMemberInfoShort(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildMemberInfoShort_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoShort_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoShort_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildMemberInfoShort(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildMemberInfoShort_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoShort_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoShort_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildBroken(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildBroken_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBroken_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildBroken_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildBroken(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildBroken_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBroken_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildBroken_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildMessage(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildMessage_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildMessage_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildMessage(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildMessage_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildMessage_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildBasicInfoChanged(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildBasicInfoChanged_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBasicInfoChanged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildBasicInfoChanged_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildBasicInfoChanged(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildBasicInfoChanged_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBasicInfoChanged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildBasicInfoChanged_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildMemberInfoChanged(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildMemberInfoChanged_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoChanged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoChanged_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildMemberInfoChanged(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildMemberInfoChanged_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoChanged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoChanged_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildPosition(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildPosition_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildPosition_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildPosition_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildPosition(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildPosition_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildPosition_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildPosition_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildSkillUp(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildSkillUp_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildSkillUp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildSkillUp_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildSkillUp(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildSkillUp_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildSkillUp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildSkillUp_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildAlliance(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildAlliance_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildAlliance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildAlliance_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildAlliance(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildAlliance_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildAlliance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildAlliance_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildNotice(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildNotice_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildNotice_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildNotice_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildNotice(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildNotice_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildNotice_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildNotice_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildEmblem(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildEmblem_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildEmblem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildEmblem_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildEmblem(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildEmblem_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildEmblem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildEmblem_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildCastleDataLoad(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildCastleDataLoad_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCastleDataLoad_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildCastleDataLoad_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildCastleDataLoad(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildCastleDataLoad_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCastleDataLoad_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildCastleDataLoad_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pGuildMasterChanged(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pGuildMasterChanged_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMasterChanged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pGuildMasterChanged_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pGuildMasterChanged(fd);
+	}
+	if( HPMHooks.count.HP_intif_pGuildMasterChanged_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMasterChanged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pGuildMasterChanged_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pQuestLog(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pQuestLog_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestLog_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pQuestLog_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pQuestLog(fd);
+	}
+	if( HPMHooks.count.HP_intif_pQuestLog_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestLog_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pQuestLog_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pQuestSave(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pQuestSave_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestSave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pQuestSave_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pQuestSave(fd);
+	}
+	if( HPMHooks.count.HP_intif_pQuestSave_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestSave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pQuestSave_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMailInboxReceived(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMailInboxReceived_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailInboxReceived_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMailInboxReceived_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMailInboxReceived(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMailInboxReceived_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailInboxReceived_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMailInboxReceived_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMailNew(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMailNew_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailNew_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMailNew_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMailNew(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMailNew_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailNew_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMailNew_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMailGetAttach(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMailGetAttach_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailGetAttach_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMailGetAttach_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMailGetAttach(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMailGetAttach_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailGetAttach_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMailGetAttach_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMailDelete(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMailDelete_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailDelete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMailDelete_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMailDelete(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMailDelete_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailDelete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMailDelete_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMailReturn(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMailReturn_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailReturn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMailReturn_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMailReturn(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMailReturn_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailReturn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMailReturn_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMailSend(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMailSend_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailSend_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMailSend_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMailSend(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMailSend_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailSend_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMailSend_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pAuctionResults(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pAuctionResults_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionResults_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pAuctionResults_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pAuctionResults(fd);
+	}
+	if( HPMHooks.count.HP_intif_pAuctionResults_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionResults_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pAuctionResults_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pAuctionRegister(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pAuctionRegister_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionRegister_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pAuctionRegister_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pAuctionRegister(fd);
+	}
+	if( HPMHooks.count.HP_intif_pAuctionRegister_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionRegister_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pAuctionRegister_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pAuctionCancel(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pAuctionCancel_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionCancel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pAuctionCancel_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pAuctionCancel(fd);
+	}
+	if( HPMHooks.count.HP_intif_pAuctionCancel_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionCancel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pAuctionCancel_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pAuctionClose(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pAuctionClose_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionClose_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pAuctionClose_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pAuctionClose(fd);
+	}
+	if( HPMHooks.count.HP_intif_pAuctionClose_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionClose_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pAuctionClose_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pAuctionMessage(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pAuctionMessage_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionMessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pAuctionMessage_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pAuctionMessage(fd);
+	}
+	if( HPMHooks.count.HP_intif_pAuctionMessage_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionMessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pAuctionMessage_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pAuctionBid(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pAuctionBid_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionBid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pAuctionBid_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pAuctionBid(fd);
+	}
+	if( HPMHooks.count.HP_intif_pAuctionBid_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionBid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pAuctionBid_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMercenaryReceived(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMercenaryReceived_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryReceived_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMercenaryReceived_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMercenaryReceived(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMercenaryReceived_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryReceived_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMercenaryReceived_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMercenaryDeleted(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMercenaryDeleted_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryDeleted_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMercenaryDeleted_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMercenaryDeleted(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMercenaryDeleted_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryDeleted_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMercenaryDeleted_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pMercenarySaved(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pMercenarySaved_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenarySaved_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pMercenarySaved_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pMercenarySaved(fd);
+	}
+	if( HPMHooks.count.HP_intif_pMercenarySaved_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenarySaved_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pMercenarySaved_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pElementalReceived(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pElementalReceived_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalReceived_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pElementalReceived_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pElementalReceived(fd);
+	}
+	if( HPMHooks.count.HP_intif_pElementalReceived_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalReceived_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pElementalReceived_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pElementalDeleted(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pElementalDeleted_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalDeleted_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pElementalDeleted_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pElementalDeleted(fd);
+	}
+	if( HPMHooks.count.HP_intif_pElementalDeleted_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalDeleted_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pElementalDeleted_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pElementalSaved(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pElementalSaved_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalSaved_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pElementalSaved_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pElementalSaved(fd);
+	}
+	if( HPMHooks.count.HP_intif_pElementalSaved_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalSaved_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pElementalSaved_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pCreatePet(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pCreatePet_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreatePet_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pCreatePet_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pCreatePet(fd);
+	}
+	if( HPMHooks.count.HP_intif_pCreatePet_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreatePet_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pCreatePet_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pRecvPetData(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pRecvPetData_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvPetData_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pRecvPetData_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pRecvPetData(fd);
+	}
+	if( HPMHooks.count.HP_intif_pRecvPetData_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvPetData_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pRecvPetData_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pSavePetOk(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pSavePetOk_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSavePetOk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pSavePetOk_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pSavePetOk(fd);
+	}
+	if( HPMHooks.count.HP_intif_pSavePetOk_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSavePetOk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pSavePetOk_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pDeletePetOk(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pDeletePetOk_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeletePetOk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pDeletePetOk_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pDeletePetOk(fd);
+	}
+	if( HPMHooks.count.HP_intif_pDeletePetOk_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeletePetOk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pDeletePetOk_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pCreateHomunculus(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pCreateHomunculus_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreateHomunculus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pCreateHomunculus_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pCreateHomunculus(fd);
+	}
+	if( HPMHooks.count.HP_intif_pCreateHomunculus_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreateHomunculus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pCreateHomunculus_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pRecvHomunculusData(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pRecvHomunculusData_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvHomunculusData_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pRecvHomunculusData_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pRecvHomunculusData(fd);
+	}
+	if( HPMHooks.count.HP_intif_pRecvHomunculusData_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvHomunculusData_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pRecvHomunculusData_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pSaveHomunculusOk(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pSaveHomunculusOk_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveHomunculusOk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pSaveHomunculusOk_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pSaveHomunculusOk(fd);
+	}
+	if( HPMHooks.count.HP_intif_pSaveHomunculusOk_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveHomunculusOk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pSaveHomunculusOk_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+void HP_intif_pDeleteHomunculusOk(int fd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_intif_pDeleteHomunculusOk_pre ) {
+		void (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeleteHomunculusOk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_intif_pDeleteHomunculusOk_pre[hIndex].func;
+			preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.intif.pDeleteHomunculusOk(fd);
+	}
+	if( HPMHooks.count.HP_intif_pDeleteHomunculusOk_post ) {
+		void (*postHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeleteHomunculusOk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_intif_pDeleteHomunculusOk_post[hIndex].func;
+			postHookFunc(&fd);
+		}
+	}
+	return;
+}
+/* ircbot */
+void HP_ircbot_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.init();
+	}
+	if( HPMHooks.count.HP_ircbot_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_ircbot_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.final();
+	}
+	if( HPMHooks.count.HP_ircbot_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_ircbot_parse(int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_ircbot_parse_pre ) {
+		int (*preHookFunc) (int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_parse_pre[hIndex].func;
+			retVal___ = preHookFunc(&fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.ircbot.parse(fd);
+	}
+	if( HPMHooks.count.HP_ircbot_parse_post ) {
+		int (*postHookFunc) (int retVal___, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_parse_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &fd);
+		}
+	}
+	return retVal___;
+}
+void HP_ircbot_parse_sub(int fd, char *str) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_parse_sub_pre ) {
+		void (*preHookFunc) (int *fd, char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_parse_sub_pre[hIndex].func;
+			preHookFunc(&fd, str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.parse_sub(fd, str);
+	}
+	if( HPMHooks.count.HP_ircbot_parse_sub_post ) {
+		void (*postHookFunc) (int *fd, char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_parse_sub_post[hIndex].func;
+			postHookFunc(&fd, str);
+		}
+	}
+	return;
+}
+void HP_ircbot_parse_source(char *source, char *nick, char *ident, char *host) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_parse_source_pre ) {
+		void (*preHookFunc) (char *source, char *nick, char *ident, char *host);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_source_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_parse_source_pre[hIndex].func;
+			preHookFunc(source, nick, ident, host);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.parse_source(source, nick, ident, host);
+	}
+	if( HPMHooks.count.HP_ircbot_parse_source_post ) {
+		void (*postHookFunc) (char *source, char *nick, char *ident, char *host);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_source_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_parse_source_post[hIndex].func;
+			postHookFunc(source, nick, ident, host);
+		}
+	}
+	return;
+}
+struct irc_func* HP_ircbot_func_search(char *function_name) {
+	int hIndex = 0;
+	struct irc_func* retVal___ = NULL;
+	if( HPMHooks.count.HP_ircbot_func_search_pre ) {
+		struct irc_func* (*preHookFunc) (char *function_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_func_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_func_search_pre[hIndex].func;
+			retVal___ = preHookFunc(function_name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.ircbot.func_search(function_name);
+	}
+	if( HPMHooks.count.HP_ircbot_func_search_post ) {
+		struct irc_func* (*postHookFunc) (struct irc_func* retVal___, char *function_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_func_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_func_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, function_name);
+		}
+	}
+	return retVal___;
+}
+int HP_ircbot_connect_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_ircbot_connect_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_connect_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_connect_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.ircbot.connect_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_ircbot_connect_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_connect_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_connect_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_ircbot_identify_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_ircbot_identify_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_identify_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_identify_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.ircbot.identify_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_ircbot_identify_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_identify_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_identify_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_ircbot_join_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_ircbot_join_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_join_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_join_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.ircbot.join_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_ircbot_join_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_join_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_join_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_ircbot_send(char *str) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_send_pre ) {
+		void (*preHookFunc) (char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_send_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_send_pre[hIndex].func;
+			preHookFunc(str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.send(str);
+	}
+	if( HPMHooks.count.HP_ircbot_send_post ) {
+		void (*postHookFunc) (char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_send_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_send_post[hIndex].func;
+			postHookFunc(str);
+		}
+	}
+	return;
+}
+void HP_ircbot_relay(char *name, const char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_relay_pre ) {
+		void (*preHookFunc) (char *name, const char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_relay_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_relay_pre[hIndex].func;
+			preHookFunc(name, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.relay(name, msg);
+	}
+	if( HPMHooks.count.HP_ircbot_relay_post ) {
+		void (*postHookFunc) (char *name, const char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_relay_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_relay_post[hIndex].func;
+			postHookFunc(name, msg);
+		}
+	}
+	return;
+}
+void HP_ircbot_pong(int fd, char *cmd, char *source, char *target, char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_pong_pre ) {
+		void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_pong_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_pong_pre[hIndex].func;
+			preHookFunc(&fd, cmd, source, target, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.pong(fd, cmd, source, target, msg);
+	}
+	if( HPMHooks.count.HP_ircbot_pong_post ) {
+		void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_pong_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_pong_post[hIndex].func;
+			postHookFunc(&fd, cmd, source, target, msg);
+		}
+	}
+	return;
+}
+void HP_ircbot_privmsg(int fd, char *cmd, char *source, char *target, char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_privmsg_pre ) {
+		void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_privmsg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_privmsg_pre[hIndex].func;
+			preHookFunc(&fd, cmd, source, target, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.privmsg(fd, cmd, source, target, msg);
+	}
+	if( HPMHooks.count.HP_ircbot_privmsg_post ) {
+		void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_privmsg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_privmsg_post[hIndex].func;
+			postHookFunc(&fd, cmd, source, target, msg);
+		}
+	}
+	return;
+}
+void HP_ircbot_userjoin(int fd, char *cmd, char *source, char *target, char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_userjoin_pre ) {
+		void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userjoin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_userjoin_pre[hIndex].func;
+			preHookFunc(&fd, cmd, source, target, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.userjoin(fd, cmd, source, target, msg);
+	}
+	if( HPMHooks.count.HP_ircbot_userjoin_post ) {
+		void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userjoin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_userjoin_post[hIndex].func;
+			postHookFunc(&fd, cmd, source, target, msg);
+		}
+	}
+	return;
+}
+void HP_ircbot_userleave(int fd, char *cmd, char *source, char *target, char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_userleave_pre ) {
+		void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userleave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_userleave_pre[hIndex].func;
+			preHookFunc(&fd, cmd, source, target, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.userleave(fd, cmd, source, target, msg);
+	}
+	if( HPMHooks.count.HP_ircbot_userleave_post ) {
+		void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userleave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_userleave_post[hIndex].func;
+			postHookFunc(&fd, cmd, source, target, msg);
+		}
+	}
+	return;
+}
+void HP_ircbot_usernick(int fd, char *cmd, char *source, char *target, char *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_ircbot_usernick_pre ) {
+		void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_usernick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_ircbot_usernick_pre[hIndex].func;
+			preHookFunc(&fd, cmd, source, target, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.ircbot.usernick(fd, cmd, source, target, msg);
+	}
+	if( HPMHooks.count.HP_ircbot_usernick_post ) {
+		void (*postHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_usernick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_ircbot_usernick_post[hIndex].func;
+			postHookFunc(&fd, cmd, source, target, msg);
+		}
+	}
+	return;
+}
+/* itemdb */
+void HP_itemdb_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.init();
+	}
+	if( HPMHooks.count.HP_itemdb_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.final();
+	}
+	if( HPMHooks.count.HP_itemdb_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_reload(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_reload_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_reload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_reload_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.reload();
+	}
+	if( HPMHooks.count.HP_itemdb_reload_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_reload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_reload_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_name_constants(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_name_constants_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name_constants_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_name_constants_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.name_constants();
+	}
+	if( HPMHooks.count.HP_itemdb_name_constants_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name_constants_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_name_constants_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_force_name_constants(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_force_name_constants_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_force_name_constants_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_force_name_constants_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.force_name_constants();
+	}
+	if( HPMHooks.count.HP_itemdb_force_name_constants_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_force_name_constants_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_force_name_constants_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_read_groups(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_read_groups_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_groups_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_groups_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.read_groups();
+	}
+	if( HPMHooks.count.HP_itemdb_read_groups_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_groups_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_groups_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_read_chains(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_read_chains_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_chains_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_chains_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.read_chains();
+	}
+	if( HPMHooks.count.HP_itemdb_read_chains_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_chains_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_chains_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_read_packages(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_read_packages_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_packages_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_packages_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.read_packages();
+	}
+	if( HPMHooks.count.HP_itemdb_read_packages_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_packages_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_packages_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_write_cached_packages(const char *config_filename) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_write_cached_packages_pre ) {
+		void (*preHookFunc) (const char *config_filename);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_write_cached_packages_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_write_cached_packages_pre[hIndex].func;
+			preHookFunc(config_filename);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.write_cached_packages(config_filename);
+	}
+	if( HPMHooks.count.HP_itemdb_write_cached_packages_post ) {
+		void (*postHookFunc) (const char *config_filename);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_write_cached_packages_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_write_cached_packages_post[hIndex].func;
+			postHookFunc(config_filename);
+		}
+	}
+	return;
+}
+bool HP_itemdb_read_cached_packages(const char *config_filename) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_itemdb_read_cached_packages_pre ) {
+		bool (*preHookFunc) (const char *config_filename);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_cached_packages_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_cached_packages_pre[hIndex].func;
+			retVal___ = preHookFunc(config_filename);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.read_cached_packages(config_filename);
+	}
+	if( HPMHooks.count.HP_itemdb_read_cached_packages_post ) {
+		bool (*postHookFunc) (bool retVal___, const char *config_filename);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_cached_packages_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_cached_packages_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, config_filename);
+		}
+	}
+	return retVal___;
+}
+struct item_data* HP_itemdb_name2id(const char *str) {
+	int hIndex = 0;
+	struct item_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_itemdb_name2id_pre ) {
+		struct item_data* (*preHookFunc) (const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name2id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_name2id_pre[hIndex].func;
+			retVal___ = preHookFunc(str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.name2id(str);
+	}
+	if( HPMHooks.count.HP_itemdb_name2id_post ) {
+		struct item_data* (*postHookFunc) (struct item_data* retVal___, const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name2id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_name2id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str);
+		}
+	}
+	return retVal___;
+}
+struct item_data* HP_itemdb_search_name(const char *name) {
+	int hIndex = 0;
+	struct item_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_itemdb_search_name_pre ) {
+		struct item_data* (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_search_name_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.search_name(name);
+	}
+	if( HPMHooks.count.HP_itemdb_search_name_post ) {
+		struct item_data* (*postHookFunc) (struct item_data* retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_search_name_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_search_name_array(struct item_data **data, int size, const char *str, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_search_name_array_pre ) {
+		int (*preHookFunc) (struct item_data **data, int *size, const char *str, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_array_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_search_name_array_pre[hIndex].func;
+			retVal___ = preHookFunc(data, &size, str, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.search_name_array(data, size, str, flag);
+	}
+	if( HPMHooks.count.HP_itemdb_search_name_array_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data **data, int *size, const char *str, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_array_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_search_name_array_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, data, &size, str, &flag);
+		}
+	}
+	return retVal___;
+}
+struct item_data* HP_itemdb_load(int nameid) {
+	int hIndex = 0;
+	struct item_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_itemdb_load_pre ) {
+		struct item_data* (*preHookFunc) (int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_load_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_load_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.load(nameid);
+	}
+	if( HPMHooks.count.HP_itemdb_load_post ) {
+		struct item_data* (*postHookFunc) (struct item_data* retVal___, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_load_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_load_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid);
+		}
+	}
+	return retVal___;
+}
+struct item_data* HP_itemdb_search(int nameid) {
+	int hIndex = 0;
+	struct item_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_itemdb_search_pre ) {
+		struct item_data* (*preHookFunc) (int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_search_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.search(nameid);
+	}
+	if( HPMHooks.count.HP_itemdb_search_post ) {
+		struct item_data* (*postHookFunc) (struct item_data* retVal___, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_parse_dbrow(char **str, const char *source, int line, int scriptopt) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_parse_dbrow_pre ) {
+		int (*preHookFunc) (char **str, const char *source, int *line, int *scriptopt);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_parse_dbrow_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_parse_dbrow_pre[hIndex].func;
+			retVal___ = preHookFunc(str, source, &line, &scriptopt);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.parse_dbrow(str, source, line, scriptopt);
+	}
+	if( HPMHooks.count.HP_itemdb_parse_dbrow_post ) {
+		int (*postHookFunc) (int retVal___, char **str, const char *source, int *line, int *scriptopt);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_parse_dbrow_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_parse_dbrow_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, source, &line, &scriptopt);
+		}
+	}
+	return retVal___;
+}
+struct item_data* HP_itemdb_exists(int nameid) {
+	int hIndex = 0;
+	struct item_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_itemdb_exists_pre ) {
+		struct item_data* (*preHookFunc) (int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_exists_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_exists_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.exists(nameid);
+	}
+	if( HPMHooks.count.HP_itemdb_exists_post ) {
+		struct item_data* (*postHookFunc) (struct item_data* retVal___, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_exists_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_exists_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid);
+		}
+	}
+	return retVal___;
+}
+bool HP_itemdb_in_group(struct item_group *group, int nameid) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_itemdb_in_group_pre ) {
+		bool (*preHookFunc) (struct item_group *group, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_in_group_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_in_group_pre[hIndex].func;
+			retVal___ = preHookFunc(group, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.in_group(group, nameid);
+	}
+	if( HPMHooks.count.HP_itemdb_in_group_post ) {
+		bool (*postHookFunc) (bool retVal___, struct item_group *group, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_in_group_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_in_group_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, group, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_group_item(struct item_group *group) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_group_item_pre ) {
+		int (*preHookFunc) (struct item_group *group);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_group_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_group_item_pre[hIndex].func;
+			retVal___ = preHookFunc(group);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.group_item(group);
+	}
+	if( HPMHooks.count.HP_itemdb_group_item_post ) {
+		int (*postHookFunc) (int retVal___, struct item_group *group);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_group_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_group_item_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, group);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_chain_item(unsigned short chain_id, int *rate) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_chain_item_pre ) {
+		int (*preHookFunc) (unsigned short *chain_id, int *rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_chain_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_chain_item_pre[hIndex].func;
+			retVal___ = preHookFunc(&chain_id, rate);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.chain_item(chain_id, rate);
+	}
+	if( HPMHooks.count.HP_itemdb_chain_item_post ) {
+		int (*postHookFunc) (int retVal___, unsigned short *chain_id, int *rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_chain_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_chain_item_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &chain_id, rate);
+		}
+	}
+	return retVal___;
+}
+void HP_itemdb_package_item(struct map_session_data *sd, struct item_package *package) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_package_item_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct item_package *package);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_package_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_package_item_pre[hIndex].func;
+			preHookFunc(sd, package);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.package_item(sd, package);
+	}
+	if( HPMHooks.count.HP_itemdb_package_item_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct item_package *package);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_package_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_package_item_post[hIndex].func;
+			postHookFunc(sd, package);
+		}
+	}
+	return;
+}
+int HP_itemdb_searchname_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_searchname_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_itemdb_searchname_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.itemdb.searchname_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_itemdb_searchname_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_itemdb_searchname_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_searchname_array_sub(DBKey key, DBData data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_searchname_array_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_array_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_itemdb_searchname_array_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, &data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.itemdb.searchname_array_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_itemdb_searchname_array_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_array_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_itemdb_searchname_array_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, &data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_searchrandomid(struct item_group *group) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_searchrandomid_pre ) {
+		int (*preHookFunc) (struct item_group *group);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchrandomid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_searchrandomid_pre[hIndex].func;
+			retVal___ = preHookFunc(group);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.searchrandomid(group);
+	}
+	if( HPMHooks.count.HP_itemdb_searchrandomid_post ) {
+		int (*postHookFunc) (int retVal___, struct item_group *group);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchrandomid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_searchrandomid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, group);
+		}
+	}
+	return retVal___;
+}
+const char* HP_itemdb_typename(int type) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_itemdb_typename_pre ) {
+		const char* (*preHookFunc) (int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_typename_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_typename_pre[hIndex].func;
+			retVal___ = preHookFunc(&type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.typename(type);
+	}
+	if( HPMHooks.count.HP_itemdb_typename_post ) {
+		const char* (*postHookFunc) (const char* retVal___, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_typename_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_typename_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_itemdb_jobid2mapid(unsigned int *bclass, unsigned int jobmask) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_jobid2mapid_pre ) {
+		void (*preHookFunc) (unsigned int *bclass, unsigned int *jobmask);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobid2mapid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_jobid2mapid_pre[hIndex].func;
+			preHookFunc(bclass, &jobmask);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.jobid2mapid(bclass, jobmask);
+	}
+	if( HPMHooks.count.HP_itemdb_jobid2mapid_post ) {
+		void (*postHookFunc) (unsigned int *bclass, unsigned int *jobmask);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobid2mapid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_jobid2mapid_post[hIndex].func;
+			postHookFunc(bclass, &jobmask);
+		}
+	}
+	return;
+}
+void HP_itemdb_create_dummy_data(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_create_dummy_data_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_create_dummy_data_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_create_dummy_data_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.create_dummy_data();
+	}
+	if( HPMHooks.count.HP_itemdb_create_dummy_data_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_create_dummy_data_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_create_dummy_data_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct item_data* HP_itemdb_create_item_data(int nameid) {
+	int hIndex = 0;
+	struct item_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_itemdb_create_item_data_pre ) {
+		struct item_data* (*preHookFunc) (int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_create_item_data_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_create_item_data_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.create_item_data(nameid);
+	}
+	if( HPMHooks.count.HP_itemdb_create_item_data_post ) {
+		struct item_data* (*postHookFunc) (struct item_data* retVal___, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_create_item_data_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_create_item_data_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_isequip(int nameid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_isequip_pre ) {
+		int (*preHookFunc) (int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_isequip_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.isequip(nameid);
+	}
+	if( HPMHooks.count.HP_itemdb_isequip_post ) {
+		int (*postHookFunc) (int retVal___, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_isequip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_isequip2(struct item_data *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_isequip2_pre ) {
+		int (*preHookFunc) (struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_isequip2_pre[hIndex].func;
+			retVal___ = preHookFunc(data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.isequip2(data);
+	}
+	if( HPMHooks.count.HP_itemdb_isequip2_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_isequip2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, data);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_isstackable(int nameid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_isstackable_pre ) {
+		int (*preHookFunc) (int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_isstackable_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.isstackable(nameid);
+	}
+	if( HPMHooks.count.HP_itemdb_isstackable_post ) {
+		int (*postHookFunc) (int retVal___, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_isstackable_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_isstackable2(struct item_data *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_isstackable2_pre ) {
+		int (*preHookFunc) (struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_isstackable2_pre[hIndex].func;
+			retVal___ = preHookFunc(data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.isstackable2(data);
+	}
+	if( HPMHooks.count.HP_itemdb_isstackable2_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_isstackable2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, data);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_isdropable_sub(struct item_data *item, int gmlv, int unused) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_isdropable_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isdropable_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_isdropable_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &unused);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.isdropable_sub(item, gmlv, unused);
+	}
+	if( HPMHooks.count.HP_itemdb_isdropable_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isdropable_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_isdropable_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &unused);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_cantrade_sub(struct item_data *item, int gmlv, int gmlv2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_cantrade_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *gmlv2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cantrade_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_cantrade_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &gmlv2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.cantrade_sub(item, gmlv, gmlv2);
+	}
+	if( HPMHooks.count.HP_itemdb_cantrade_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *gmlv2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cantrade_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_cantrade_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &gmlv2);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_canpartnertrade_sub(struct item_data *item, int gmlv, int gmlv2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_canpartnertrade_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *gmlv2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canpartnertrade_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_canpartnertrade_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &gmlv2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.canpartnertrade_sub(item, gmlv, gmlv2);
+	}
+	if( HPMHooks.count.HP_itemdb_canpartnertrade_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *gmlv2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canpartnertrade_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_canpartnertrade_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &gmlv2);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_cansell_sub(struct item_data *item, int gmlv, int unused) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_cansell_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cansell_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_cansell_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &unused);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.cansell_sub(item, gmlv, unused);
+	}
+	if( HPMHooks.count.HP_itemdb_cansell_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cansell_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_cansell_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &unused);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_cancartstore_sub(struct item_data *item, int gmlv, int unused) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_cancartstore_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cancartstore_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_cancartstore_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &unused);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.cancartstore_sub(item, gmlv, unused);
+	}
+	if( HPMHooks.count.HP_itemdb_cancartstore_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cancartstore_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_cancartstore_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &unused);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_canstore_sub(struct item_data *item, int gmlv, int unused) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_canstore_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canstore_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_canstore_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &unused);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.canstore_sub(item, gmlv, unused);
+	}
+	if( HPMHooks.count.HP_itemdb_canstore_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canstore_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_canstore_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &unused);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_canguildstore_sub(struct item_data *item, int gmlv, int unused) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_canguildstore_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canguildstore_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_canguildstore_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &unused);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.canguildstore_sub(item, gmlv, unused);
+	}
+	if( HPMHooks.count.HP_itemdb_canguildstore_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canguildstore_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_canguildstore_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &unused);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_canmail_sub(struct item_data *item, int gmlv, int unused) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_canmail_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canmail_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_canmail_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &unused);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.canmail_sub(item, gmlv, unused);
+	}
+	if( HPMHooks.count.HP_itemdb_canmail_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canmail_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_canmail_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &unused);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_canauction_sub(struct item_data *item, int gmlv, int unused) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_canauction_sub_pre ) {
+		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canauction_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_canauction_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &unused);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.canauction_sub(item, gmlv, unused);
+	}
+	if( HPMHooks.count.HP_itemdb_canauction_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *item, int *gmlv, int *unused);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canauction_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_canauction_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &unused);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_isrestricted(struct item *item, int gmlv, int gmlv2, int ( *func ) (struct item_data *, int, int)) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_isrestricted_pre ) {
+		int (*preHookFunc) (struct item *item, int *gmlv, int *gmlv2, int ( *func ) (struct item_data *, int, int));
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isrestricted_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_isrestricted_pre[hIndex].func;
+			retVal___ = preHookFunc(item, &gmlv, &gmlv2, func);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.isrestricted(item, gmlv, gmlv2, func);
+	}
+	if( HPMHooks.count.HP_itemdb_isrestricted_post ) {
+		int (*postHookFunc) (int retVal___, struct item *item, int *gmlv, int *gmlv2, int ( *func ) (struct item_data *, int, int));
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isrestricted_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_isrestricted_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item, &gmlv, &gmlv2, func);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_isidentified(int nameid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_isidentified_pre ) {
+		int (*preHookFunc) (int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_isidentified_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.isidentified(nameid);
+	}
+	if( HPMHooks.count.HP_itemdb_isidentified_post ) {
+		int (*postHookFunc) (int retVal___, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_isidentified_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_isidentified2(struct item_data *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_isidentified2_pre ) {
+		int (*preHookFunc) (struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_isidentified2_pre[hIndex].func;
+			retVal___ = preHookFunc(data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.isidentified2(data);
+	}
+	if( HPMHooks.count.HP_itemdb_isidentified2_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_isidentified2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, data);
+		}
+	}
+	return retVal___;
+}
+bool HP_itemdb_read_itemavail(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_itemdb_read_itemavail_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_itemavail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_itemavail_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.read_itemavail(str, columns, current);
+	}
+	if( HPMHooks.count.HP_itemdb_read_itemavail_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_itemavail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_itemavail_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_itemdb_read_itemtrade(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_itemdb_read_itemtrade_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_itemtrade_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_itemtrade_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.read_itemtrade(str, columns, current);
+	}
+	if( HPMHooks.count.HP_itemdb_read_itemtrade_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_itemtrade_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_itemtrade_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_itemdb_read_itemdelay(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_itemdb_read_itemdelay_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_itemdelay_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_itemdelay_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.read_itemdelay(str, columns, current);
+	}
+	if( HPMHooks.count.HP_itemdb_read_itemdelay_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_itemdelay_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_itemdelay_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_itemdb_read_stack(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_itemdb_read_stack_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_stack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_stack_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.read_stack(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_itemdb_read_stack_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_stack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_stack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_itemdb_read_buyingstore(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_itemdb_read_buyingstore_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_buyingstore_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_buyingstore_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.read_buyingstore(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_itemdb_read_buyingstore_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_buyingstore_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_buyingstore_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_itemdb_read_nouse(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_itemdb_read_nouse_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_nouse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_nouse_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.read_nouse(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_itemdb_read_nouse_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_nouse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_nouse_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_combo_split_atoi(char *str, int *val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_combo_split_atoi_pre ) {
+		int (*preHookFunc) (char *str, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_combo_split_atoi_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_combo_split_atoi_pre[hIndex].func;
+			retVal___ = preHookFunc(str, val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.combo_split_atoi(str, val);
+	}
+	if( HPMHooks.count.HP_itemdb_combo_split_atoi_post ) {
+		int (*postHookFunc) (int retVal___, char *str, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_combo_split_atoi_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_combo_split_atoi_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, val);
+		}
+	}
+	return retVal___;
+}
+void HP_itemdb_read_combos(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_read_combos_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_combos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_combos_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.read_combos();
+	}
+	if( HPMHooks.count.HP_itemdb_read_combos_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_combos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_combos_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_itemdb_gendercheck(struct item_data *id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_gendercheck_pre ) {
+		int (*preHookFunc) (struct item_data *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_gendercheck_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_gendercheck_pre[hIndex].func;
+			retVal___ = preHookFunc(id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.gendercheck(id);
+	}
+	if( HPMHooks.count.HP_itemdb_gendercheck_post ) {
+		int (*postHookFunc) (int retVal___, struct item_data *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_gendercheck_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_gendercheck_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, id);
+		}
+	}
+	return retVal___;
+}
+void HP_itemdb_re_split_atoi(char *str, int *atk, int *matk) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_re_split_atoi_pre ) {
+		void (*preHookFunc) (char *str, int *atk, int *matk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_re_split_atoi_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_re_split_atoi_pre[hIndex].func;
+			preHookFunc(str, atk, matk);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.re_split_atoi(str, atk, matk);
+	}
+	if( HPMHooks.count.HP_itemdb_re_split_atoi_post ) {
+		void (*postHookFunc) (char *str, int *atk, int *matk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_re_split_atoi_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_re_split_atoi_post[hIndex].func;
+			postHookFunc(str, atk, matk);
+		}
+	}
+	return;
+}
+int HP_itemdb_readdb(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_readdb_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_readdb_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.readdb();
+	}
+	if( HPMHooks.count.HP_itemdb_readdb_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_readdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_read_sqldb(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_read_sqldb_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_sqldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_sqldb_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.read_sqldb();
+	}
+	if( HPMHooks.count.HP_itemdb_read_sqldb_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_sqldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_sqldb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+uint64 HP_itemdb_unique_id(int8 flag, int64 value) {
+	int hIndex = 0;
+	uint64 retVal___;
+	memset(&retVal___, '\0', sizeof(uint64));
+	if( HPMHooks.count.HP_itemdb_unique_id_pre ) {
+		uint64 (*preHookFunc) (int8 *flag, int64 *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_unique_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_unique_id_pre[hIndex].func;
+			retVal___ = preHookFunc(&flag, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.unique_id(flag, value);
+	}
+	if( HPMHooks.count.HP_itemdb_unique_id_post ) {
+		uint64 (*postHookFunc) (uint64 retVal___, int8 *flag, int64 *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_unique_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_unique_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &flag, &value);
+		}
+	}
+	return retVal___;
+}
+int HP_itemdb_uid_load(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_uid_load_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_uid_load_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_uid_load_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.itemdb.uid_load();
+	}
+	if( HPMHooks.count.HP_itemdb_uid_load_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_uid_load_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_uid_load_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_itemdb_read(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_read_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_read_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.read();
+	}
+	if( HPMHooks.count.HP_itemdb_read_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_read_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_itemdb_destroy_item_data(struct item_data *self, int free_self) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_itemdb_destroy_item_data_pre ) {
+		void (*preHookFunc) (struct item_data *self, int *free_self);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_destroy_item_data_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_itemdb_destroy_item_data_pre[hIndex].func;
+			preHookFunc(self, &free_self);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.itemdb.destroy_item_data(self, free_self);
+	}
+	if( HPMHooks.count.HP_itemdb_destroy_item_data_post ) {
+		void (*postHookFunc) (struct item_data *self, int *free_self);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_destroy_item_data_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_itemdb_destroy_item_data_post[hIndex].func;
+			postHookFunc(self, &free_self);
+		}
+	}
+	return;
+}
+int HP_itemdb_final_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_itemdb_final_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_itemdb_final_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.itemdb.final_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_itemdb_final_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_itemdb_final_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+/* logs */
+void HP_logs_pick_pc(struct map_session_data *sd, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_pick_pc_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_pc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_pick_pc_pre[hIndex].func;
+			preHookFunc(sd, &type, &amount, itm, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.pick_pc(sd, type, amount, itm, data);
+	}
+	if( HPMHooks.count.HP_logs_pick_pc_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_pc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_pick_pc_post[hIndex].func;
+			postHookFunc(sd, &type, &amount, itm, data);
+		}
+	}
+	return;
+}
+void HP_logs_pick_mob(struct mob_data *md, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_pick_mob_pre ) {
+		void (*preHookFunc) (struct mob_data *md, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_mob_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_pick_mob_pre[hIndex].func;
+			preHookFunc(md, &type, &amount, itm, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.pick_mob(md, type, amount, itm, data);
+	}
+	if( HPMHooks.count.HP_logs_pick_mob_post ) {
+		void (*postHookFunc) (struct mob_data *md, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_mob_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_pick_mob_post[hIndex].func;
+			postHookFunc(md, &type, &amount, itm, data);
+		}
+	}
+	return;
+}
+void HP_logs_zeny(struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_zeny_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, e_log_pick_type *type, struct map_session_data *src_sd, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_zeny_pre[hIndex].func;
+			preHookFunc(sd, &type, src_sd, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.zeny(sd, type, src_sd, amount);
+	}
+	if( HPMHooks.count.HP_logs_zeny_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type *type, struct map_session_data *src_sd, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_zeny_post[hIndex].func;
+			postHookFunc(sd, &type, src_sd, &amount);
+		}
+	}
+	return;
+}
+void HP_logs_npc(struct map_session_data *sd, const char *message) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_npc_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_npc_pre[hIndex].func;
+			preHookFunc(sd, message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.npc(sd, message);
+	}
+	if( HPMHooks.count.HP_logs_npc_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_npc_post[hIndex].func;
+			postHookFunc(sd, message);
+		}
+	}
+	return;
+}
+void HP_logs_chat(e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_chat_pre ) {
+		void (*preHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char *mapname, int *x, int *y, const char *dst_charname, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_chat_pre[hIndex].func;
+			preHookFunc(&type, &type_id, &src_charid, &src_accid, mapname, &x, &y, dst_charname, message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.chat(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message);
+	}
+	if( HPMHooks.count.HP_logs_chat_post ) {
+		void (*postHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char *mapname, int *x, int *y, const char *dst_charname, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_chat_post[hIndex].func;
+			postHookFunc(&type, &type_id, &src_charid, &src_accid, mapname, &x, &y, dst_charname, message);
+		}
+	}
+	return;
+}
+void HP_logs_atcommand(struct map_session_data *sd, const char *message) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_atcommand_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_atcommand_pre[hIndex].func;
+			preHookFunc(sd, message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.atcommand(sd, message);
+	}
+	if( HPMHooks.count.HP_logs_atcommand_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_atcommand_post[hIndex].func;
+			postHookFunc(sd, message);
+		}
+	}
+	return;
+}
+void HP_logs_branch(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_branch_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_branch_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.branch(sd);
+	}
+	if( HPMHooks.count.HP_logs_branch_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_branch_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_logs_mvpdrop(struct map_session_data *sd, int monster_id, int *log_mvp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_mvpdrop_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_mvpdrop_pre[hIndex].func;
+			preHookFunc(sd, &monster_id, log_mvp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.mvpdrop(sd, monster_id, log_mvp);
+	}
+	if( HPMHooks.count.HP_logs_mvpdrop_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_mvpdrop_post[hIndex].func;
+			postHookFunc(sd, &monster_id, log_mvp);
+		}
+	}
+	return;
+}
+void HP_logs_pick_sub(int id, int16 m, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_pick_sub_pre ) {
+		void (*preHookFunc) (int *id, int16 *m, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_pick_sub_pre[hIndex].func;
+			preHookFunc(&id, &m, &type, &amount, itm, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.pick_sub(id, m, type, amount, itm, data);
+	}
+	if( HPMHooks.count.HP_logs_pick_sub_post ) {
+		void (*postHookFunc) (int *id, int16 *m, e_log_pick_type *type, int *amount, struct item *itm, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_pick_sub_post[hIndex].func;
+			postHookFunc(&id, &m, &type, &amount, itm, data);
+		}
+	}
+	return;
+}
+void HP_logs_zeny_sub(struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_zeny_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, e_log_pick_type *type, struct map_session_data *src_sd, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_zeny_sub_pre[hIndex].func;
+			preHookFunc(sd, &type, src_sd, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.zeny_sub(sd, type, src_sd, amount);
+	}
+	if( HPMHooks.count.HP_logs_zeny_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type *type, struct map_session_data *src_sd, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_zeny_sub_post[hIndex].func;
+			postHookFunc(sd, &type, src_sd, &amount);
+		}
+	}
+	return;
+}
+void HP_logs_npc_sub(struct map_session_data *sd, const char *message) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_npc_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_npc_sub_pre[hIndex].func;
+			preHookFunc(sd, message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.npc_sub(sd, message);
+	}
+	if( HPMHooks.count.HP_logs_npc_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_npc_sub_post[hIndex].func;
+			postHookFunc(sd, message);
+		}
+	}
+	return;
+}
+void HP_logs_chat_sub(e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_chat_sub_pre ) {
+		void (*preHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char *mapname, int *x, int *y, const char *dst_charname, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_chat_sub_pre[hIndex].func;
+			preHookFunc(&type, &type_id, &src_charid, &src_accid, mapname, &x, &y, dst_charname, message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.chat_sub(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message);
+	}
+	if( HPMHooks.count.HP_logs_chat_sub_post ) {
+		void (*postHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char *mapname, int *x, int *y, const char *dst_charname, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_chat_sub_post[hIndex].func;
+			postHookFunc(&type, &type_id, &src_charid, &src_accid, mapname, &x, &y, dst_charname, message);
+		}
+	}
+	return;
+}
+void HP_logs_atcommand_sub(struct map_session_data *sd, const char *message) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_atcommand_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_atcommand_sub_pre[hIndex].func;
+			preHookFunc(sd, message);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.atcommand_sub(sd, message);
+	}
+	if( HPMHooks.count.HP_logs_atcommand_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *message);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_atcommand_sub_post[hIndex].func;
+			postHookFunc(sd, message);
+		}
+	}
+	return;
+}
+void HP_logs_branch_sub(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_branch_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_branch_sub_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.branch_sub(sd);
+	}
+	if( HPMHooks.count.HP_logs_branch_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_branch_sub_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_logs_mvpdrop_sub(struct map_session_data *sd, int monster_id, int *log_mvp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_mvpdrop_sub_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_mvpdrop_sub_pre[hIndex].func;
+			preHookFunc(sd, &monster_id, log_mvp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.mvpdrop_sub(sd, monster_id, log_mvp);
+	}
+	if( HPMHooks.count.HP_logs_mvpdrop_sub_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_mvpdrop_sub_post[hIndex].func;
+			postHookFunc(sd, &monster_id, log_mvp);
+		}
+	}
+	return;
+}
+int HP_logs_config_read(const char *cfgName) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_logs_config_read_pre ) {
+		int (*preHookFunc) (const char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_config_read_pre[hIndex].func;
+			retVal___ = preHookFunc(cfgName);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.logs.config_read(cfgName);
+	}
+	if( HPMHooks.count.HP_logs_config_read_post ) {
+		int (*postHookFunc) (int retVal___, const char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_config_read_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cfgName);
+		}
+	}
+	return retVal___;
+}
+void HP_logs_config_done(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_config_done_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_config_done_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_config_done_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.config_done();
+	}
+	if( HPMHooks.count.HP_logs_config_done_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_config_done_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_config_done_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_logs_sql_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_sql_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_sql_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_sql_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.sql_init();
+	}
+	if( HPMHooks.count.HP_logs_sql_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_sql_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_sql_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_logs_sql_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_logs_sql_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_sql_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_sql_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.logs.sql_final();
+	}
+	if( HPMHooks.count.HP_logs_sql_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_sql_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_sql_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+char HP_logs_picktype2char(e_log_pick_type type) {
+	int hIndex = 0;
+	char retVal___;
+	memset(&retVal___, '\0', sizeof(char));
+	if( HPMHooks.count.HP_logs_picktype2char_pre ) {
+		char (*preHookFunc) (e_log_pick_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_picktype2char_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_picktype2char_pre[hIndex].func;
+			retVal___ = preHookFunc(&type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.logs.picktype2char(type);
+	}
+	if( HPMHooks.count.HP_logs_picktype2char_post ) {
+		char (*postHookFunc) (char retVal___, e_log_pick_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_picktype2char_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_picktype2char_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &type);
+		}
+	}
+	return retVal___;
+}
+char HP_logs_chattype2char(e_log_chat_type type) {
+	int hIndex = 0;
+	char retVal___;
+	memset(&retVal___, '\0', sizeof(char));
+	if( HPMHooks.count.HP_logs_chattype2char_pre ) {
+		char (*preHookFunc) (e_log_chat_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chattype2char_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_chattype2char_pre[hIndex].func;
+			retVal___ = preHookFunc(&type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.logs.chattype2char(type);
+	}
+	if( HPMHooks.count.HP_logs_chattype2char_post ) {
+		char (*postHookFunc) (char retVal___, e_log_chat_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chattype2char_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_chattype2char_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &type);
+		}
+	}
+	return retVal___;
+}
+bool HP_logs_should_log_item(int nameid, int amount, int refine, struct item_data *id) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_logs_should_log_item_pre ) {
+		bool (*preHookFunc) (int *nameid, int *amount, int *refine, struct item_data *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_should_log_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_logs_should_log_item_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid, &amount, &refine, id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.logs.should_log_item(nameid, amount, refine, id);
+	}
+	if( HPMHooks.count.HP_logs_should_log_item_post ) {
+		bool (*postHookFunc) (bool retVal___, int *nameid, int *amount, int *refine, struct item_data *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_should_log_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_logs_should_log_item_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid, &amount, &refine, id);
+		}
+	}
+	return retVal___;
+}
+/* mail */
+void HP_mail_clear(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mail_clear_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_clear_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mail.clear(sd);
+	}
+	if( HPMHooks.count.HP_mail_clear_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_clear_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_mail_removeitem(struct map_session_data *sd, short flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mail_removeitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, short *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removeitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_removeitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mail.removeitem(sd, flag);
+	}
+	if( HPMHooks.count.HP_mail_removeitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, short *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removeitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_removeitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_mail_removezeny(struct map_session_data *sd, short flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mail_removezeny_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, short *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removezeny_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_removezeny_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mail.removezeny(sd, flag);
+	}
+	if( HPMHooks.count.HP_mail_removezeny_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, short *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removezeny_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_removezeny_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+unsigned char HP_mail_setitem(struct map_session_data *sd, int idx, int amount) {
+	int hIndex = 0;
+	unsigned char retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned char));
+	if( HPMHooks.count.HP_mail_setitem_pre ) {
+		unsigned char (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_setitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &idx, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mail.setitem(sd, idx, amount);
+	}
+	if( HPMHooks.count.HP_mail_setitem_post ) {
+		unsigned char (*postHookFunc) (unsigned char retVal___, struct map_session_data *sd, int *idx, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_setitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &idx, &amount);
+		}
+	}
+	return retVal___;
+}
+bool HP_mail_setattachment(struct map_session_data *sd, struct mail_message *msg) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mail_setattachment_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, struct mail_message *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setattachment_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_setattachment_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mail.setattachment(sd, msg);
+	}
+	if( HPMHooks.count.HP_mail_setattachment_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct mail_message *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setattachment_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_setattachment_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, msg);
+		}
+	}
+	return retVal___;
+}
+void HP_mail_getattachment(struct map_session_data *sd, int zeny, struct item *item) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mail_getattachment_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *zeny, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_getattachment_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_getattachment_pre[hIndex].func;
+			preHookFunc(sd, &zeny, item);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mail.getattachment(sd, zeny, item);
+	}
+	if( HPMHooks.count.HP_mail_getattachment_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *zeny, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_getattachment_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_getattachment_post[hIndex].func;
+			postHookFunc(sd, &zeny, item);
+		}
+	}
+	return;
+}
+int HP_mail_openmail(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mail_openmail_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_openmail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_openmail_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mail.openmail(sd);
+	}
+	if( HPMHooks.count.HP_mail_openmail_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_openmail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_openmail_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_mail_deliveryfail(struct map_session_data *sd, struct mail_message *msg) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mail_deliveryfail_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct mail_message *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_deliveryfail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_deliveryfail_pre[hIndex].func;
+			preHookFunc(sd, msg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mail.deliveryfail(sd, msg);
+	}
+	if( HPMHooks.count.HP_mail_deliveryfail_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct mail_message *msg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_deliveryfail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_deliveryfail_post[hIndex].func;
+			postHookFunc(sd, msg);
+		}
+	}
+	return;
+}
+bool HP_mail_invalid_operation(struct map_session_data *sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mail_invalid_operation_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_invalid_operation_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mail_invalid_operation_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mail.invalid_operation(sd);
+	}
+	if( HPMHooks.count.HP_mail_invalid_operation_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_invalid_operation_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mail_invalid_operation_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+/* map */
+void HP_map_zone_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_zone_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.zone_init();
+	}
+	if( HPMHooks.count.HP_map_zone_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_map_zone_remove(int m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_zone_remove_pre ) {
+		void (*preHookFunc) (int *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_remove_pre[hIndex].func;
+			preHookFunc(&m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.zone_remove(m);
+	}
+	if( HPMHooks.count.HP_map_zone_remove_post ) {
+		void (*postHookFunc) (int *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_remove_post[hIndex].func;
+			postHookFunc(&m);
+		}
+	}
+	return;
+}
+void HP_map_zone_apply(int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_zone_apply_pre ) {
+		void (*preHookFunc) (int *m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_apply_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_apply_pre[hIndex].func;
+			preHookFunc(&m, zone, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.zone_apply(m, zone, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_map_zone_apply_post ) {
+		void (*postHookFunc) (int *m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_apply_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_apply_post[hIndex].func;
+			postHookFunc(&m, zone, start, buffer, filepath);
+		}
+	}
+	return;
+}
+void HP_map_zone_change(int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_zone_change_pre ) {
+		void (*preHookFunc) (int *m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_change_pre[hIndex].func;
+			preHookFunc(&m, zone, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.zone_change(m, zone, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_map_zone_change_post ) {
+		void (*postHookFunc) (int *m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_change_post[hIndex].func;
+			postHookFunc(&m, zone, start, buffer, filepath);
+		}
+	}
+	return;
+}
+void HP_map_zone_change2(int m, struct map_zone_data *zone) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_zone_change2_pre ) {
+		void (*preHookFunc) (int *m, struct map_zone_data *zone);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_change2_pre[hIndex].func;
+			preHookFunc(&m, zone);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.zone_change2(m, zone);
+	}
+	if( HPMHooks.count.HP_map_zone_change2_post ) {
+		void (*postHookFunc) (int *m, struct map_zone_data *zone);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_change2_post[hIndex].func;
+			postHookFunc(&m, zone);
+		}
+	}
+	return;
+}
+int HP_map_getcell(int16 m, int16 x, int16 y, cell_chk cellchk) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_getcell_pre ) {
+		int (*preHookFunc) (int16 *m, int16 *x, int16 *y, cell_chk *cellchk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_getcell_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, &x, &y, &cellchk);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.getcell(m, x, y, cellchk);
+	}
+	if( HPMHooks.count.HP_map_getcell_post ) {
+		int (*postHookFunc) (int retVal___, int16 *m, int16 *x, int16 *y, cell_chk *cellchk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_getcell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, &x, &y, &cellchk);
+		}
+	}
+	return retVal___;
+}
+void HP_map_setgatcell(int16 m, int16 x, int16 y, int gat) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_setgatcell_pre ) {
+		void (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *gat);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setgatcell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_setgatcell_pre[hIndex].func;
+			preHookFunc(&m, &x, &y, &gat);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.setgatcell(m, x, y, gat);
+	}
+	if( HPMHooks.count.HP_map_setgatcell_post ) {
+		void (*postHookFunc) (int16 *m, int16 *x, int16 *y, int *gat);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setgatcell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_setgatcell_post[hIndex].func;
+			postHookFunc(&m, &x, &y, &gat);
+		}
+	}
+	return;
+}
+void HP_map_cellfromcache(struct map_data *m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_cellfromcache_pre ) {
+		void (*preHookFunc) (struct map_data *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cellfromcache_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_cellfromcache_pre[hIndex].func;
+			preHookFunc(m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.cellfromcache(m);
+	}
+	if( HPMHooks.count.HP_map_cellfromcache_post ) {
+		void (*postHookFunc) (struct map_data *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cellfromcache_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_cellfromcache_post[hIndex].func;
+			postHookFunc(m);
+		}
+	}
+	return;
+}
+void HP_map_setusers(int p1) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_setusers_pre ) {
+		void (*preHookFunc) (int *p1);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setusers_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_setusers_pre[hIndex].func;
+			preHookFunc(&p1);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.setusers(p1);
+	}
+	if( HPMHooks.count.HP_map_setusers_post ) {
+		void (*postHookFunc) (int *p1);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setusers_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_setusers_post[hIndex].func;
+			postHookFunc(&p1);
+		}
+	}
+	return;
+}
+int HP_map_getusers(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_getusers_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getusers_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_getusers_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.getusers();
+	}
+	if( HPMHooks.count.HP_map_getusers_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getusers_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_getusers_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_map_usercount(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_usercount_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_usercount_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_usercount_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.usercount();
+	}
+	if( HPMHooks.count.HP_map_usercount_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_usercount_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_usercount_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_map_freeblock(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_freeblock_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_freeblock_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.freeblock(bl);
+	}
+	if( HPMHooks.count.HP_map_freeblock_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_freeblock_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_map_freeblock_lock(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_freeblock_lock_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_lock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_freeblock_lock_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.freeblock_lock();
+	}
+	if( HPMHooks.count.HP_map_freeblock_lock_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_lock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_freeblock_lock_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_map_freeblock_unlock(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_freeblock_unlock_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_unlock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_freeblock_unlock_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.freeblock_unlock();
+	}
+	if( HPMHooks.count.HP_map_freeblock_unlock_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_unlock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_freeblock_unlock_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_map_addblock(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_addblock_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addblock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_addblock_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.addblock(bl);
+	}
+	if( HPMHooks.count.HP_map_addblock_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addblock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_addblock_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_map_delblock(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_delblock_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delblock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_delblock_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.delblock(bl);
+	}
+	if( HPMHooks.count.HP_map_delblock_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delblock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_delblock_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_map_moveblock(struct block_list *bl, int x1, int y1, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_moveblock_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *x1, int *y1, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_moveblock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_moveblock_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &x1, &y1, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.moveblock(bl, x1, y1, tick);
+	}
+	if( HPMHooks.count.HP_map_moveblock_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *x1, int *y1, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_moveblock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_moveblock_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &x1, &y1, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_map_count_oncell(int16 m, int16 x, int16 y, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_count_oncell_pre ) {
+		int (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_count_oncell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_count_oncell_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, &x, &y, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.count_oncell(m, x, y, type);
+	}
+	if( HPMHooks.count.HP_map_count_oncell_post ) {
+		int (*postHookFunc) (int retVal___, int16 *m, int16 *x, int16 *y, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_count_oncell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_count_oncell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, &x, &y, &type);
+		}
+	}
+	return retVal___;
+}
+struct skill_unit* HP_map_find_skill_unit_oncell(struct block_list *target, int16 x, int16 y, uint16 skill_id, struct skill_unit *out_unit, int flag) {
+	int hIndex = 0;
+	struct skill_unit* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_find_skill_unit_oncell_pre ) {
+		struct skill_unit* (*preHookFunc) (struct block_list *target, int16 *x, int16 *y, uint16 *skill_id, struct skill_unit *out_unit, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_find_skill_unit_oncell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_find_skill_unit_oncell_pre[hIndex].func;
+			retVal___ = preHookFunc(target, &x, &y, &skill_id, out_unit, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.find_skill_unit_oncell(target, x, y, skill_id, out_unit, flag);
+	}
+	if( HPMHooks.count.HP_map_find_skill_unit_oncell_post ) {
+		struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, struct block_list *target, int16 *x, int16 *y, uint16 *skill_id, struct skill_unit *out_unit, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_find_skill_unit_oncell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_find_skill_unit_oncell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, target, &x, &y, &skill_id, out_unit, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_map_get_new_object_id(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_get_new_object_id_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_get_new_object_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_get_new_object_id_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.get_new_object_id();
+	}
+	if( HPMHooks.count.HP_map_get_new_object_id_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_get_new_object_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_get_new_object_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_map_search_freecell(struct block_list *src, int16 m, int16 *x, int16 *y, int16 rx, int16 ry, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_search_freecell_pre ) {
+		int (*preHookFunc) (struct block_list *src, int16 *m, int16 *x, int16 *y, int16 *rx, int16 *ry, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_search_freecell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_search_freecell_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &m, x, y, &rx, &ry, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.search_freecell(src, m, x, y, rx, ry, flag);
+	}
+	if( HPMHooks.count.HP_map_search_freecell_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, int16 *m, int16 *x, int16 *y, int16 *rx, int16 *ry, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_search_freecell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_search_freecell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &m, x, y, &rx, &ry, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_map_quit(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_quit_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_quit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_quit_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.quit(sd);
+	}
+	if( HPMHooks.count.HP_map_quit_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_quit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_quit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+bool HP_map_addnpc(int16 m, struct npc_data *nd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_map_addnpc_pre ) {
+		bool (*preHookFunc) (int16 *m, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnpc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_addnpc_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.addnpc(m, nd);
+	}
+	if( HPMHooks.count.HP_map_addnpc_post ) {
+		bool (*postHookFunc) (bool retVal___, int16 *m, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnpc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_addnpc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_map_clearflooritem_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_clearflooritem_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_clearflooritem_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.clearflooritem_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_map_clearflooritem_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_clearflooritem_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_map_removemobs_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_removemobs_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_removemobs_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.removemobs_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_map_removemobs_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_removemobs_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_map_clearflooritem(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_clearflooritem_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_clearflooritem_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.clearflooritem(bl);
+	}
+	if( HPMHooks.count.HP_map_clearflooritem_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_clearflooritem_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+int HP_map_addflooritem(struct item *item_data, int amount, int16 m, int16 x, int16 y, int first_charid, int second_charid, int third_charid, int flags) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_addflooritem_pre ) {
+		int (*preHookFunc) (struct item *item_data, int *amount, int16 *m, int16 *x, int16 *y, int *first_charid, int *second_charid, int *third_charid, int *flags);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addflooritem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_addflooritem_pre[hIndex].func;
+			retVal___ = preHookFunc(item_data, &amount, &m, &x, &y, &first_charid, &second_charid, &third_charid, &flags);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.addflooritem(item_data, amount, m, x, y, first_charid, second_charid, third_charid, flags);
+	}
+	if( HPMHooks.count.HP_map_addflooritem_post ) {
+		int (*postHookFunc) (int retVal___, struct item *item_data, int *amount, int16 *m, int16 *x, int16 *y, int *first_charid, int *second_charid, int *third_charid, int *flags);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addflooritem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_addflooritem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item_data, &amount, &m, &x, &y, &first_charid, &second_charid, &third_charid, &flags);
+		}
+	}
+	return retVal___;
+}
+void HP_map_addnickdb(int charid, const char *nick) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_addnickdb_pre ) {
+		void (*preHookFunc) (int *charid, const char *nick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnickdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_addnickdb_pre[hIndex].func;
+			preHookFunc(&charid, nick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.addnickdb(charid, nick);
+	}
+	if( HPMHooks.count.HP_map_addnickdb_post ) {
+		void (*postHookFunc) (int *charid, const char *nick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnickdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_addnickdb_post[hIndex].func;
+			postHookFunc(&charid, nick);
+		}
+	}
+	return;
+}
+void HP_map_delnickdb(int charid, const char *nick) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_delnickdb_pre ) {
+		void (*preHookFunc) (int *charid, const char *nick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delnickdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_delnickdb_pre[hIndex].func;
+			preHookFunc(&charid, nick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.delnickdb(charid, nick);
+	}
+	if( HPMHooks.count.HP_map_delnickdb_post ) {
+		void (*postHookFunc) (int *charid, const char *nick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delnickdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_delnickdb_post[hIndex].func;
+			postHookFunc(&charid, nick);
+		}
+	}
+	return;
+}
+void HP_map_reqnickdb(struct map_session_data *sd, int charid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_reqnickdb_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *charid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reqnickdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_reqnickdb_pre[hIndex].func;
+			preHookFunc(sd, &charid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.reqnickdb(sd, charid);
+	}
+	if( HPMHooks.count.HP_map_reqnickdb_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *charid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reqnickdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_reqnickdb_post[hIndex].func;
+			postHookFunc(sd, &charid);
+		}
+	}
+	return;
+}
+const char* HP_map_charid2nick(int charid) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_charid2nick_pre ) {
+		const char* (*preHookFunc) (int *charid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2nick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_charid2nick_pre[hIndex].func;
+			retVal___ = preHookFunc(&charid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.charid2nick(charid);
+	}
+	if( HPMHooks.count.HP_map_charid2nick_post ) {
+		const char* (*postHookFunc) (const char* retVal___, int *charid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2nick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_charid2nick_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &charid);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_map_charid2sd(int charid) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_charid2sd_pre ) {
+		struct map_session_data* (*preHookFunc) (int *charid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2sd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_charid2sd_pre[hIndex].func;
+			retVal___ = preHookFunc(&charid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.charid2sd(charid);
+	}
+	if( HPMHooks.count.HP_map_charid2sd_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int *charid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2sd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_charid2sd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &charid);
+		}
+	}
+	return retVal___;
+}
+void HP_map_vforeachpc(int ( *func ) (struct map_session_data *sd, va_list args), va_list args) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_vforeachpc_pre ) {
+		void (*preHookFunc) (int ( *func ) (struct map_session_data *sd, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachpc_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_vforeachpc_pre[hIndex].func;
+			preHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		HPMHooks.source.map.vforeachpc(func, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachpc_post ) {
+		void (*postHookFunc) (int ( *func ) (struct map_session_data *sd, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachpc_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_vforeachpc_post[hIndex].func;
+			postHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return;
+}
+void HP_map_vforeachmob(int ( *func ) (struct mob_data *md, va_list args), va_list args) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_vforeachmob_pre ) {
+		void (*preHookFunc) (int ( *func ) (struct mob_data *md, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachmob_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_vforeachmob_pre[hIndex].func;
+			preHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		HPMHooks.source.map.vforeachmob(func, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachmob_post ) {
+		void (*postHookFunc) (int ( *func ) (struct mob_data *md, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachmob_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_vforeachmob_post[hIndex].func;
+			postHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return;
+}
+void HP_map_vforeachnpc(int ( *func ) (struct npc_data *nd, va_list args), va_list args) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_vforeachnpc_pre ) {
+		void (*preHookFunc) (int ( *func ) (struct npc_data *nd, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachnpc_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_vforeachnpc_pre[hIndex].func;
+			preHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		HPMHooks.source.map.vforeachnpc(func, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachnpc_post ) {
+		void (*postHookFunc) (int ( *func ) (struct npc_data *nd, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachnpc_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_vforeachnpc_post[hIndex].func;
+			postHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return;
+}
+void HP_map_vforeachregen(int ( *func ) (struct block_list *bl, va_list args), va_list args) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_vforeachregen_pre ) {
+		void (*preHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachregen_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_vforeachregen_pre[hIndex].func;
+			preHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		HPMHooks.source.map.vforeachregen(func, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachregen_post ) {
+		void (*postHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachregen_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_vforeachregen_post[hIndex].func;
+			postHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return;
+}
+void HP_map_vforeachiddb(int ( *func ) (struct block_list *bl, va_list args), va_list args) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_vforeachiddb_pre ) {
+		void (*preHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachiddb_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_vforeachiddb_pre[hIndex].func;
+			preHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		HPMHooks.source.map.vforeachiddb(func, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachiddb_post ) {
+		void (*postHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachiddb_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_vforeachiddb_post[hIndex].func;
+			postHookFunc(func, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return;
+}
+int HP_map_vforeachinrange(int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforeachinrange_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinrange_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforeachinrange_pre[hIndex].func;
+			retVal___ = preHookFunc(func, center, &range, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforeachinrange(func, center, range, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachinrange_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinrange_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforeachinrange_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, center, &range, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforeachinshootrange(int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforeachinshootrange_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinshootrange_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforeachinshootrange_pre[hIndex].func;
+			retVal___ = preHookFunc(func, center, &range, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforeachinshootrange(func, center, range, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachinshootrange_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinshootrange_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforeachinshootrange_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, center, &range, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforeachinarea(int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforeachinarea_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinarea_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforeachinarea_pre[hIndex].func;
+			retVal___ = preHookFunc(func, &m, &x0, &y0, &x1, &y1, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforeachinarea(func, m, x0, y0, x1, y1, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachinarea_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinarea_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforeachinarea_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, &m, &x0, &y0, &x1, &y1, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforcountinrange(int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int count, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforcountinrange_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *count, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinrange_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforcountinrange_pre[hIndex].func;
+			retVal___ = preHookFunc(func, center, &range, &count, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforcountinrange(func, center, range, count, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforcountinrange_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int *count, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinrange_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforcountinrange_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, center, &range, &count, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforcountinarea(int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int count, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforcountinarea_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *count, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinarea_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforcountinarea_pre[hIndex].func;
+			retVal___ = preHookFunc(func, &m, &x0, &y0, &x1, &y1, &count, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforcountinarea(func, m, x0, y0, x1, y1, count, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforcountinarea_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *count, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinarea_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforcountinarea_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, &m, &x0, &y0, &x1, &y1, &count, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforeachinmovearea(int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int16 dx, int16 dy, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforeachinmovearea_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int16 *dx, int16 *dy, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmovearea_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforeachinmovearea_pre[hIndex].func;
+			retVal___ = preHookFunc(func, center, &range, &dx, &dy, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforeachinmovearea(func, center, range, dx, dy, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachinmovearea_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 *range, int16 *dx, int16 *dy, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmovearea_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforeachinmovearea_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, center, &range, &dx, &dy, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforeachincell(int ( *func ) (struct block_list *, va_list), int16 m, int16 x, int16 y, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforeachincell_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x, int16 *y, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachincell_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforeachincell_pre[hIndex].func;
+			retVal___ = preHookFunc(func, &m, &x, &y, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforeachincell(func, m, x, y, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachincell_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x, int16 *y, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachincell_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforeachincell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, &m, &x, &y, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforeachinpath(int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int16 range, int length, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforeachinpath_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int16 *range, int *length, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinpath_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforeachinpath_pre[hIndex].func;
+			retVal___ = preHookFunc(func, &m, &x0, &y0, &x1, &y1, &range, &length, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforeachinpath(func, m, x0, y0, x1, y1, range, length, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachinpath_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int16 *range, int *length, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinpath_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforeachinpath_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, &m, &x0, &y0, &x1, &y1, &range, &length, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforeachinmap(int ( *func ) (struct block_list *, va_list), int16 m, int type, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforeachinmap_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int *type, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmap_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_vforeachinmap_pre[hIndex].func;
+			retVal___ = preHookFunc(func, &m, &type, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.map.vforeachinmap(func, m, type, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachinmap_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *m, int *type, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmap_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_vforeachinmap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, &m, &type, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_vforeachininstance(int ( *func ) (struct block_list *, va_list), int16 instance_id, int type, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_vforeachininstance_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *instance_id, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachininstance_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_vforeachininstance_pre[hIndex].func;
+			retVal___ = preHookFunc(func, &instance_id, &type, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.vforeachininstance(func, instance_id, type, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_vforeachininstance_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 *instance_id, int *type, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachininstance_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_vforeachininstance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, &instance_id, &type, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_map_id2sd(int id) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_id2sd_pre ) {
+		struct map_session_data* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2sd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_id2sd_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.id2sd(id);
+	}
+	if( HPMHooks.count.HP_map_id2sd_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2sd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_id2sd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+struct mob_data* HP_map_id2md(int id) {
+	int hIndex = 0;
+	struct mob_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_id2md_pre ) {
+		struct mob_data* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2md_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_id2md_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.id2md(id);
+	}
+	if( HPMHooks.count.HP_map_id2md_post ) {
+		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2md_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_id2md_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+struct npc_data* HP_map_id2nd(int id) {
+	int hIndex = 0;
+	struct npc_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_id2nd_pre ) {
+		struct npc_data* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2nd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_id2nd_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.id2nd(id);
+	}
+	if( HPMHooks.count.HP_map_id2nd_post ) {
+		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2nd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_id2nd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+struct homun_data* HP_map_id2hd(int id) {
+	int hIndex = 0;
+	struct homun_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_id2hd_pre ) {
+		struct homun_data* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2hd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_id2hd_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.id2hd(id);
+	}
+	if( HPMHooks.count.HP_map_id2hd_post ) {
+		struct homun_data* (*postHookFunc) (struct homun_data* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2hd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_id2hd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+struct mercenary_data* HP_map_id2mc(int id) {
+	int hIndex = 0;
+	struct mercenary_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_id2mc_pre ) {
+		struct mercenary_data* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2mc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_id2mc_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.id2mc(id);
+	}
+	if( HPMHooks.count.HP_map_id2mc_post ) {
+		struct mercenary_data* (*postHookFunc) (struct mercenary_data* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2mc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_id2mc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+struct chat_data* HP_map_id2cd(int id) {
+	int hIndex = 0;
+	struct chat_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_id2cd_pre ) {
+		struct chat_data* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2cd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_id2cd_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.id2cd(id);
+	}
+	if( HPMHooks.count.HP_map_id2cd_post ) {
+		struct chat_data* (*postHookFunc) (struct chat_data* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2cd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_id2cd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_map_id2bl(int id) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_id2bl_pre ) {
+		struct block_list* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2bl_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_id2bl_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.id2bl(id);
+	}
+	if( HPMHooks.count.HP_map_id2bl_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2bl_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_id2bl_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+bool HP_map_blid_exists(int id) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_map_blid_exists_pre ) {
+		bool (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_blid_exists_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_blid_exists_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.blid_exists(id);
+	}
+	if( HPMHooks.count.HP_map_blid_exists_post ) {
+		bool (*postHookFunc) (bool retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_blid_exists_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_blid_exists_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+int16 HP_map_mapindex2mapid(unsigned short mapindex) {
+	int hIndex = 0;
+	int16 retVal___;
+	memset(&retVal___, '\0', sizeof(int16));
+	if( HPMHooks.count.HP_map_mapindex2mapid_pre ) {
+		int16 (*preHookFunc) (unsigned short *mapindex);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapindex2mapid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_mapindex2mapid_pre[hIndex].func;
+			retVal___ = preHookFunc(&mapindex);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.mapindex2mapid(mapindex);
+	}
+	if( HPMHooks.count.HP_map_mapindex2mapid_post ) {
+		int16 (*postHookFunc) (int16 retVal___, unsigned short *mapindex);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapindex2mapid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_mapindex2mapid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &mapindex);
+		}
+	}
+	return retVal___;
+}
+int16 HP_map_mapname2mapid(const char *name) {
+	int hIndex = 0;
+	int16 retVal___;
+	memset(&retVal___, '\0', sizeof(int16));
+	if( HPMHooks.count.HP_map_mapname2mapid_pre ) {
+		int16 (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2mapid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_mapname2mapid_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.mapname2mapid(name);
+	}
+	if( HPMHooks.count.HP_map_mapname2mapid_post ) {
+		int16 (*postHookFunc) (int16 retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2mapid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_mapname2mapid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+int HP_map_mapname2ipport(unsigned short name, uint32 *ip, uint16 *port) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_mapname2ipport_pre ) {
+		int (*preHookFunc) (unsigned short *name, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2ipport_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_mapname2ipport_pre[hIndex].func;
+			retVal___ = preHookFunc(&name, ip, port);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.mapname2ipport(name, ip, port);
+	}
+	if( HPMHooks.count.HP_map_mapname2ipport_post ) {
+		int (*postHookFunc) (int retVal___, unsigned short *name, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2ipport_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_mapname2ipport_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &name, ip, port);
+		}
+	}
+	return retVal___;
+}
+int HP_map_setipport(unsigned short mapindex, uint32 ip, uint16 port) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_setipport_pre ) {
+		int (*preHookFunc) (unsigned short *mapindex, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setipport_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_setipport_pre[hIndex].func;
+			retVal___ = preHookFunc(&mapindex, &ip, &port);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.setipport(mapindex, ip, port);
+	}
+	if( HPMHooks.count.HP_map_setipport_post ) {
+		int (*postHookFunc) (int retVal___, unsigned short *mapindex, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setipport_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_setipport_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &mapindex, &ip, &port);
+		}
+	}
+	return retVal___;
+}
+int HP_map_eraseipport(unsigned short mapindex, uint32 ip, uint16 port) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_eraseipport_pre ) {
+		int (*preHookFunc) (unsigned short *mapindex, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseipport_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_eraseipport_pre[hIndex].func;
+			retVal___ = preHookFunc(&mapindex, &ip, &port);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.eraseipport(mapindex, ip, port);
+	}
+	if( HPMHooks.count.HP_map_eraseipport_post ) {
+		int (*postHookFunc) (int retVal___, unsigned short *mapindex, uint32 *ip, uint16 *port);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseipport_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_eraseipport_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &mapindex, &ip, &port);
+		}
+	}
+	return retVal___;
+}
+int HP_map_eraseallipport(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_eraseallipport_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_eraseallipport_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.eraseallipport();
+	}
+	if( HPMHooks.count.HP_map_eraseallipport_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_eraseallipport_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_map_addiddb(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_addiddb_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addiddb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_addiddb_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.addiddb(bl);
+	}
+	if( HPMHooks.count.HP_map_addiddb_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addiddb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_addiddb_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+void HP_map_deliddb(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_deliddb_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_deliddb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_deliddb_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.deliddb(bl);
+	}
+	if( HPMHooks.count.HP_map_deliddb_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_deliddb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_deliddb_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+struct map_session_data* HP_map_nick2sd(const char *nick) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_nick2sd_pre ) {
+		struct map_session_data* (*preHookFunc) (const char *nick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick2sd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_nick2sd_pre[hIndex].func;
+			retVal___ = preHookFunc(nick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.nick2sd(nick);
+	}
+	if( HPMHooks.count.HP_map_nick2sd_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, const char *nick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick2sd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_nick2sd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nick);
+		}
+	}
+	return retVal___;
+}
+struct mob_data* HP_map_getmob_boss(int16 m) {
+	int hIndex = 0;
+	struct mob_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_getmob_boss_pre ) {
+		struct mob_data* (*preHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getmob_boss_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_getmob_boss_pre[hIndex].func;
+			retVal___ = preHookFunc(&m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.getmob_boss(m);
+	}
+	if( HPMHooks.count.HP_map_getmob_boss_post ) {
+		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getmob_boss_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_getmob_boss_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m);
+		}
+	}
+	return retVal___;
+}
+struct mob_data* HP_map_id2boss(int id) {
+	int hIndex = 0;
+	struct mob_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_id2boss_pre ) {
+		struct mob_data* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2boss_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_id2boss_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.id2boss(id);
+	}
+	if( HPMHooks.count.HP_map_id2boss_post ) {
+		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2boss_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_id2boss_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+void HP_map_reloadnpc(bool clear) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_reloadnpc_pre ) {
+		void (*preHookFunc) (bool *clear);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_reloadnpc_pre[hIndex].func;
+			preHookFunc(&clear);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.reloadnpc(clear);
+	}
+	if( HPMHooks.count.HP_map_reloadnpc_post ) {
+		void (*postHookFunc) (bool *clear);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_reloadnpc_post[hIndex].func;
+			postHookFunc(&clear);
+		}
+	}
+	return;
+}
+int HP_map_check_dir(int s_dir, int t_dir) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_check_dir_pre ) {
+		int (*preHookFunc) (int *s_dir, int *t_dir);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_check_dir_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_check_dir_pre[hIndex].func;
+			retVal___ = preHookFunc(&s_dir, &t_dir);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.check_dir(s_dir, t_dir);
+	}
+	if( HPMHooks.count.HP_map_check_dir_post ) {
+		int (*postHookFunc) (int retVal___, int *s_dir, int *t_dir);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_check_dir_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_check_dir_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &s_dir, &t_dir);
+		}
+	}
+	return retVal___;
+}
+uint8 HP_map_calc_dir(struct block_list *src, int16 x, int16 y) {
+	int hIndex = 0;
+	uint8 retVal___;
+	memset(&retVal___, '\0', sizeof(uint8));
+	if( HPMHooks.count.HP_map_calc_dir_pre ) {
+		uint8 (*preHookFunc) (struct block_list *src, int16 *x, int16 *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_calc_dir_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_calc_dir_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.calc_dir(src, x, y);
+	}
+	if( HPMHooks.count.HP_map_calc_dir_post ) {
+		uint8 (*postHookFunc) (uint8 retVal___, struct block_list *src, int16 *x, int16 *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_calc_dir_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_calc_dir_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &x, &y);
+		}
+	}
+	return retVal___;
+}
+int HP_map_random_dir(struct block_list *bl, short *x, short *y) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_random_dir_pre ) {
+		int (*preHookFunc) (struct block_list *bl, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_random_dir_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_random_dir_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, x, y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.random_dir(bl, x, y);
+	}
+	if( HPMHooks.count.HP_map_random_dir_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_random_dir_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_random_dir_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, x, y);
+		}
+	}
+	return retVal___;
+}
+int HP_map_cleanup_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_cleanup_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_cleanup_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.cleanup_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_cleanup_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_cleanup_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_delmap(char *mapname) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_delmap_pre ) {
+		int (*preHookFunc) (char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_delmap_pre[hIndex].func;
+			retVal___ = preHookFunc(mapname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.delmap(mapname);
+	}
+	if( HPMHooks.count.HP_map_delmap_post ) {
+		int (*postHookFunc) (int retVal___, char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_delmap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mapname);
+		}
+	}
+	return retVal___;
+}
+void HP_map_flags_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_flags_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_flags_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_flags_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.flags_init();
+	}
+	if( HPMHooks.count.HP_map_flags_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_flags_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_flags_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+bool HP_map_iwall_set(int16 m, int16 x, int16 y, int size, int8 dir, bool shootable, const char *wall_name) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_map_iwall_set_pre ) {
+		bool (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *size, int8 *dir, bool *shootable, const char *wall_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_set_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_iwall_set_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, &x, &y, &size, &dir, &shootable, wall_name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.iwall_set(m, x, y, size, dir, shootable, wall_name);
+	}
+	if( HPMHooks.count.HP_map_iwall_set_post ) {
+		bool (*postHookFunc) (bool retVal___, int16 *m, int16 *x, int16 *y, int *size, int8 *dir, bool *shootable, const char *wall_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_set_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_iwall_set_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, &x, &y, &size, &dir, &shootable, wall_name);
+		}
+	}
+	return retVal___;
+}
+void HP_map_iwall_get(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_iwall_get_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_get_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_iwall_get_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.iwall_get(sd);
+	}
+	if( HPMHooks.count.HP_map_iwall_get_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_get_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_iwall_get_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_map_iwall_remove(const char *wall_name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_iwall_remove_pre ) {
+		void (*preHookFunc) (const char *wall_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_iwall_remove_pre[hIndex].func;
+			preHookFunc(wall_name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.iwall_remove(wall_name);
+	}
+	if( HPMHooks.count.HP_map_iwall_remove_post ) {
+		void (*postHookFunc) (const char *wall_name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_iwall_remove_post[hIndex].func;
+			postHookFunc(wall_name);
+		}
+	}
+	return;
+}
+int HP_map_addmobtolist(unsigned short m, struct spawn_data *spawn) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_addmobtolist_pre ) {
+		int (*preHookFunc) (unsigned short *m, struct spawn_data *spawn);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmobtolist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_addmobtolist_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, spawn);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.addmobtolist(m, spawn);
+	}
+	if( HPMHooks.count.HP_map_addmobtolist_post ) {
+		int (*postHookFunc) (int retVal___, unsigned short *m, struct spawn_data *spawn);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmobtolist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_addmobtolist_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, spawn);
+		}
+	}
+	return retVal___;
+}
+void HP_map_spawnmobs(int16 m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_spawnmobs_pre ) {
+		void (*preHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_spawnmobs_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_spawnmobs_pre[hIndex].func;
+			preHookFunc(&m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.spawnmobs(m);
+	}
+	if( HPMHooks.count.HP_map_spawnmobs_post ) {
+		void (*postHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_spawnmobs_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_spawnmobs_post[hIndex].func;
+			postHookFunc(&m);
+		}
+	}
+	return;
+}
+void HP_map_removemobs(int16 m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_removemobs_pre ) {
+		void (*preHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_removemobs_pre[hIndex].func;
+			preHookFunc(&m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.removemobs(m);
+	}
+	if( HPMHooks.count.HP_map_removemobs_post ) {
+		void (*postHookFunc) (int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_removemobs_post[hIndex].func;
+			postHookFunc(&m);
+		}
+	}
+	return;
+}
+void HP_map_addmap2db(struct map_data *m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_addmap2db_pre ) {
+		void (*preHookFunc) (struct map_data *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap2db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_addmap2db_pre[hIndex].func;
+			preHookFunc(m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.addmap2db(m);
+	}
+	if( HPMHooks.count.HP_map_addmap2db_post ) {
+		void (*postHookFunc) (struct map_data *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap2db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_addmap2db_post[hIndex].func;
+			postHookFunc(m);
+		}
+	}
+	return;
+}
+void HP_map_removemapdb(struct map_data *m) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_removemapdb_pre ) {
+		void (*preHookFunc) (struct map_data *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemapdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_removemapdb_pre[hIndex].func;
+			preHookFunc(m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.removemapdb(m);
+	}
+	if( HPMHooks.count.HP_map_removemapdb_post ) {
+		void (*postHookFunc) (struct map_data *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemapdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_removemapdb_post[hIndex].func;
+			postHookFunc(m);
+		}
+	}
+	return;
+}
+void HP_map_clean(int i) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_clean_pre ) {
+		void (*preHookFunc) (int *i);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clean_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_clean_pre[hIndex].func;
+			preHookFunc(&i);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.clean(i);
+	}
+	if( HPMHooks.count.HP_map_clean_post ) {
+		void (*postHookFunc) (int *i);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clean_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_clean_post[hIndex].func;
+			postHookFunc(&i);
+		}
+	}
+	return;
+}
+void HP_map_do_shutdown(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_do_shutdown_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_do_shutdown_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_do_shutdown_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.do_shutdown();
+	}
+	if( HPMHooks.count.HP_map_do_shutdown_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_do_shutdown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_do_shutdown_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_map_freeblock_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_freeblock_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_freeblock_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.freeblock_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_map_freeblock_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_freeblock_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_map_searchrandfreecell(int16 m, int16 *x, int16 *y, int stack) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_searchrandfreecell_pre ) {
+		int (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *stack);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_searchrandfreecell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_searchrandfreecell_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, x, y, &stack);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.searchrandfreecell(m, x, y, stack);
+	}
+	if( HPMHooks.count.HP_map_searchrandfreecell_post ) {
+		int (*postHookFunc) (int retVal___, int16 *m, int16 *x, int16 *y, int *stack);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_searchrandfreecell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_searchrandfreecell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, x, y, &stack);
+		}
+	}
+	return retVal___;
+}
+int HP_map_count_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_count_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_count_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_count_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.count_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_count_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_count_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_count_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+DBData HP_map_create_charid2nick(DBKey key, va_list args) {
+	int hIndex = 0;
+	DBData retVal___;
+	memset(&retVal___, '\0', sizeof(DBData));
+	if( HPMHooks.count.HP_map_create_charid2nick_pre ) {
+		DBData (*preHookFunc) (DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_create_charid2nick_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_create_charid2nick_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.map.create_charid2nick(key, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_create_charid2nick_post ) {
+		DBData (*postHookFunc) (DBData retVal___, DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_create_charid2nick_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_create_charid2nick_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_removemobs_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_removemobs_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_removemobs_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.removemobs_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_removemobs_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_removemobs_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+struct mapcell HP_map_gat2cell(int gat) {
+	int hIndex = 0;
+	struct mapcell retVal___;
+	memset(&retVal___, '\0', sizeof(struct mapcell));
+	if( HPMHooks.count.HP_map_gat2cell_pre ) {
+		struct mapcell (*preHookFunc) (int *gat);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_gat2cell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_gat2cell_pre[hIndex].func;
+			retVal___ = preHookFunc(&gat);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.gat2cell(gat);
+	}
+	if( HPMHooks.count.HP_map_gat2cell_post ) {
+		struct mapcell (*postHookFunc) (struct mapcell retVal___, int *gat);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_gat2cell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_gat2cell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &gat);
+		}
+	}
+	return retVal___;
+}
+int HP_map_cell2gat(struct mapcell cell) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_cell2gat_pre ) {
+		int (*preHookFunc) (struct mapcell *cell);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cell2gat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_cell2gat_pre[hIndex].func;
+			retVal___ = preHookFunc(&cell);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.cell2gat(cell);
+	}
+	if( HPMHooks.count.HP_map_cell2gat_post ) {
+		int (*postHookFunc) (int retVal___, struct mapcell *cell);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cell2gat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_cell2gat_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &cell);
+		}
+	}
+	return retVal___;
+}
+int HP_map_getcellp(struct map_data *m, int16 x, int16 y, cell_chk cellchk) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_getcellp_pre ) {
+		int (*preHookFunc) (struct map_data *m, int16 *x, int16 *y, cell_chk *cellchk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcellp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_getcellp_pre[hIndex].func;
+			retVal___ = preHookFunc(m, &x, &y, &cellchk);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.getcellp(m, x, y, cellchk);
+	}
+	if( HPMHooks.count.HP_map_getcellp_post ) {
+		int (*postHookFunc) (int retVal___, struct map_data *m, int16 *x, int16 *y, cell_chk *cellchk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcellp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_getcellp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, m, &x, &y, &cellchk);
+		}
+	}
+	return retVal___;
+}
+void HP_map_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_setcell_pre ) {
+		void (*preHookFunc) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setcell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_setcell_pre[hIndex].func;
+			preHookFunc(&m, &x, &y, &cell, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.setcell(m, x, y, cell, flag);
+	}
+	if( HPMHooks.count.HP_map_setcell_post ) {
+		void (*postHookFunc) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setcell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_setcell_post[hIndex].func;
+			postHookFunc(&m, &x, &y, &cell, &flag);
+		}
+	}
+	return;
+}
+int HP_map_sub_getcellp(struct map_data *m, int16 x, int16 y, cell_chk cellchk) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_sub_getcellp_pre ) {
+		int (*preHookFunc) (struct map_data *m, int16 *x, int16 *y, cell_chk *cellchk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_getcellp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_sub_getcellp_pre[hIndex].func;
+			retVal___ = preHookFunc(m, &x, &y, &cellchk);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.sub_getcellp(m, x, y, cellchk);
+	}
+	if( HPMHooks.count.HP_map_sub_getcellp_post ) {
+		int (*postHookFunc) (int retVal___, struct map_data *m, int16 *x, int16 *y, cell_chk *cellchk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_getcellp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_sub_getcellp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, m, &x, &y, &cellchk);
+		}
+	}
+	return retVal___;
+}
+void HP_map_sub_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_sub_setcell_pre ) {
+		void (*preHookFunc) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_setcell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_sub_setcell_pre[hIndex].func;
+			preHookFunc(&m, &x, &y, &cell, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.sub_setcell(m, x, y, cell, flag);
+	}
+	if( HPMHooks.count.HP_map_sub_setcell_post ) {
+		void (*postHookFunc) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_setcell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_sub_setcell_post[hIndex].func;
+			postHookFunc(&m, &x, &y, &cell, &flag);
+		}
+	}
+	return;
+}
+void HP_map_iwall_nextxy(int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 *y1) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_iwall_nextxy_pre ) {
+		void (*preHookFunc) (int16 *x, int16 *y, int8 *dir, int *pos, int16 *x1, int16 *y1);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_nextxy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_iwall_nextxy_pre[hIndex].func;
+			preHookFunc(&x, &y, &dir, &pos, x1, y1);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.iwall_nextxy(x, y, dir, pos, x1, y1);
+	}
+	if( HPMHooks.count.HP_map_iwall_nextxy_post ) {
+		void (*postHookFunc) (int16 *x, int16 *y, int8 *dir, int *pos, int16 *x1, int16 *y1);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_nextxy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_iwall_nextxy_post[hIndex].func;
+			postHookFunc(&x, &y, &dir, &pos, x1, y1);
+		}
+	}
+	return;
+}
+DBData HP_map_create_map_data_other_server(DBKey key, va_list args) {
+	int hIndex = 0;
+	DBData retVal___;
+	memset(&retVal___, '\0', sizeof(DBData));
+	if( HPMHooks.count.HP_map_create_map_data_other_server_pre ) {
+		DBData (*preHookFunc) (DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_create_map_data_other_server_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_create_map_data_other_server_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.map.create_map_data_other_server(key, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_create_map_data_other_server_post ) {
+		DBData (*postHookFunc) (DBData retVal___, DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_create_map_data_other_server_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_create_map_data_other_server_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_eraseallipport_sub(DBKey key, DBData *data, va_list va) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_eraseallipport_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list va);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_sub_pre; hIndex++ ) {
+			va_list va___copy; va_copy(va___copy, va);
+			preHookFunc = HPMHooks.list.HP_map_eraseallipport_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, va___copy);
+			va_end(va___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list va___copy; va_copy(va___copy, va);
+		retVal___ = HPMHooks.source.map.eraseallipport_sub(key, data, va___copy);
+		va_end(va___copy);
+	}
+	if( HPMHooks.count.HP_map_eraseallipport_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list va);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_sub_post; hIndex++ ) {
+			va_list va___copy; va_copy(va___copy, va);
+			postHookFunc = HPMHooks.list.HP_map_eraseallipport_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, va___copy);
+			va_end(va___copy);
+		}
+	}
+	return retVal___;
+}
+char* HP_map_init_mapcache(FILE *fp) {
+	int hIndex = 0;
+	char* retVal___ = NULL;
+	if( HPMHooks.count.HP_map_init_mapcache_pre ) {
+		char* (*preHookFunc) (FILE *fp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_init_mapcache_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_init_mapcache_pre[hIndex].func;
+			retVal___ = preHookFunc(fp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.init_mapcache(fp);
+	}
+	if( HPMHooks.count.HP_map_init_mapcache_post ) {
+		char* (*postHookFunc) (char* retVal___, FILE *fp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_init_mapcache_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_init_mapcache_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fp);
+		}
+	}
+	return retVal___;
+}
+int HP_map_readfromcache(struct map_data *m, char *buffer) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_readfromcache_pre ) {
+		int (*preHookFunc) (struct map_data *m, char *buffer);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readfromcache_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_readfromcache_pre[hIndex].func;
+			retVal___ = preHookFunc(m, buffer);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.readfromcache(m, buffer);
+	}
+	if( HPMHooks.count.HP_map_readfromcache_post ) {
+		int (*postHookFunc) (int retVal___, struct map_data *m, char *buffer);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readfromcache_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_readfromcache_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, m, buffer);
+		}
+	}
+	return retVal___;
+}
+int HP_map_addmap(char *mapname) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_addmap_pre ) {
+		int (*preHookFunc) (char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_addmap_pre[hIndex].func;
+			retVal___ = preHookFunc(mapname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.addmap(mapname);
+	}
+	if( HPMHooks.count.HP_map_addmap_post ) {
+		int (*postHookFunc) (int retVal___, char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_addmap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mapname);
+		}
+	}
+	return retVal___;
+}
+void HP_map_delmapid(int id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_delmapid_pre ) {
+		void (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmapid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_delmapid_pre[hIndex].func;
+			preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.delmapid(id);
+	}
+	if( HPMHooks.count.HP_map_delmapid_post ) {
+		void (*postHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmapid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_delmapid_post[hIndex].func;
+			postHookFunc(&id);
+		}
+	}
+	return;
+}
+void HP_map_zone_db_clear(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_zone_db_clear_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_db_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_db_clear_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.zone_db_clear();
+	}
+	if( HPMHooks.count.HP_map_zone_db_clear_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_db_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_db_clear_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_map_list_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_list_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_list_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_list_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.list_final();
+	}
+	if( HPMHooks.count.HP_map_list_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_list_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_list_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_map_waterheight(char *mapname) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_waterheight_pre ) {
+		int (*preHookFunc) (char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_waterheight_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_waterheight_pre[hIndex].func;
+			retVal___ = preHookFunc(mapname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.waterheight(mapname);
+	}
+	if( HPMHooks.count.HP_map_waterheight_post ) {
+		int (*postHookFunc) (int retVal___, char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_waterheight_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_waterheight_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mapname);
+		}
+	}
+	return retVal___;
+}
+int HP_map_readgat(struct map_data *m) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_readgat_pre ) {
+		int (*preHookFunc) (struct map_data *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readgat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_readgat_pre[hIndex].func;
+			retVal___ = preHookFunc(m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.readgat(m);
+	}
+	if( HPMHooks.count.HP_map_readgat_post ) {
+		int (*postHookFunc) (int retVal___, struct map_data *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readgat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_readgat_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, m);
+		}
+	}
+	return retVal___;
+}
+int HP_map_readallmaps(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_readallmaps_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readallmaps_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_readallmaps_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.readallmaps();
+	}
+	if( HPMHooks.count.HP_map_readallmaps_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readallmaps_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_readallmaps_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_map_config_read(char *cfgName) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_config_read_pre ) {
+		int (*preHookFunc) (char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_config_read_pre[hIndex].func;
+			retVal___ = preHookFunc(cfgName);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.config_read(cfgName);
+	}
+	if( HPMHooks.count.HP_map_config_read_post ) {
+		int (*postHookFunc) (int retVal___, char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_config_read_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cfgName);
+		}
+	}
+	return retVal___;
+}
+int HP_map_config_read_sub(char *cfgName) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_config_read_sub_pre ) {
+		int (*preHookFunc) (char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_config_read_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_config_read_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(cfgName);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.config_read_sub(cfgName);
+	}
+	if( HPMHooks.count.HP_map_config_read_sub_post ) {
+		int (*postHookFunc) (int retVal___, char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_config_read_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_config_read_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cfgName);
+		}
+	}
+	return retVal___;
+}
+void HP_map_reloadnpc_sub(char *cfgName) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_reloadnpc_sub_pre ) {
+		void (*preHookFunc) (char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_reloadnpc_sub_pre[hIndex].func;
+			preHookFunc(cfgName);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.reloadnpc_sub(cfgName);
+	}
+	if( HPMHooks.count.HP_map_reloadnpc_sub_post ) {
+		void (*postHookFunc) (char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_reloadnpc_sub_post[hIndex].func;
+			postHookFunc(cfgName);
+		}
+	}
+	return;
+}
+int HP_map_inter_config_read(char *cfgName) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_inter_config_read_pre ) {
+		int (*preHookFunc) (char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_inter_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_inter_config_read_pre[hIndex].func;
+			retVal___ = preHookFunc(cfgName);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.inter_config_read(cfgName);
+	}
+	if( HPMHooks.count.HP_map_inter_config_read_post ) {
+		int (*postHookFunc) (int retVal___, char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_inter_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_inter_config_read_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cfgName);
+		}
+	}
+	return retVal___;
+}
+int HP_map_sql_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_sql_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sql_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_sql_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.sql_init();
+	}
+	if( HPMHooks.count.HP_map_sql_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sql_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_sql_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_map_sql_close(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_sql_close_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sql_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_sql_close_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.sql_close();
+	}
+	if( HPMHooks.count.HP_map_sql_close_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sql_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_sql_close_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+bool HP_map_zone_mf_cache(int m, char *flag, char *params) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_map_zone_mf_cache_pre ) {
+		bool (*preHookFunc) (int *m, char *flag, char *params);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_mf_cache_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_mf_cache_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, flag, params);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.zone_mf_cache(m, flag, params);
+	}
+	if( HPMHooks.count.HP_map_zone_mf_cache_post ) {
+		bool (*postHookFunc) (bool retVal___, int *m, char *flag, char *params);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_mf_cache_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_mf_cache_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, flag, params);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_map_zone_str2itemid(const char *name) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_map_zone_str2itemid_pre ) {
+		unsigned short (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_str2itemid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_str2itemid_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.zone_str2itemid(name);
+	}
+	if( HPMHooks.count.HP_map_zone_str2itemid_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_str2itemid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_str2itemid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_map_zone_str2skillid(const char *name) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_map_zone_str2skillid_pre ) {
+		unsigned short (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_str2skillid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_str2skillid_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.zone_str2skillid(name);
+	}
+	if( HPMHooks.count.HP_map_zone_str2skillid_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_str2skillid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_str2skillid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+enum bl_type HP_map_zone_bl_type(const char *entry, enum map_zone_skill_subtype *subtype) {
+	int hIndex = 0;
+	enum bl_type retVal___;
+	memset(&retVal___, '\0', sizeof(enum bl_type));
+	if( HPMHooks.count.HP_map_zone_bl_type_pre ) {
+		enum bl_type (*preHookFunc) (const char *entry, enum map_zone_skill_subtype *subtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_bl_type_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_zone_bl_type_pre[hIndex].func;
+			retVal___ = preHookFunc(entry, subtype);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.zone_bl_type(entry, subtype);
+	}
+	if( HPMHooks.count.HP_map_zone_bl_type_post ) {
+		enum bl_type (*postHookFunc) (enum bl_type retVal___, const char *entry, enum map_zone_skill_subtype *subtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_bl_type_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_zone_bl_type_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, entry, subtype);
+		}
+	}
+	return retVal___;
+}
+void HP_map_read_zone_db(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_read_zone_db_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_read_zone_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_read_zone_db_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.read_zone_db();
+	}
+	if( HPMHooks.count.HP_map_read_zone_db_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_read_zone_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_read_zone_db_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_map_db_final(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_db_final_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_db_final_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_db_final_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.db_final(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_db_final_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_db_final_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_db_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_nick_db_final(DBKey key, DBData *data, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_nick_db_final_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick_db_final_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_map_nick_db_final_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.map.nick_db_final(key, data, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_map_nick_db_final_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick_db_final_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_map_nick_db_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_cleanup_db_sub(DBKey key, DBData *data, va_list va) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_cleanup_db_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list va);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_db_sub_pre; hIndex++ ) {
+			va_list va___copy; va_copy(va___copy, va);
+			preHookFunc = HPMHooks.list.HP_map_cleanup_db_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, va___copy);
+			va_end(va___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list va___copy; va_copy(va___copy, va);
+		retVal___ = HPMHooks.source.map.cleanup_db_sub(key, data, va___copy);
+		va_end(va___copy);
+	}
+	if( HPMHooks.count.HP_map_cleanup_db_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list va);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_db_sub_post; hIndex++ ) {
+			va_list va___copy; va_copy(va___copy, va);
+			postHookFunc = HPMHooks.list.HP_map_cleanup_db_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, va___copy);
+			va_end(va___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_map_abort_sub(struct map_session_data *sd, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_map_abort_sub_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_abort_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_map_abort_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.map.abort_sub(sd, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_map_abort_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_abort_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_map_abort_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_map_helpscreen(bool do_exit) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_helpscreen_pre ) {
+		void (*preHookFunc) (bool *do_exit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_helpscreen_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_helpscreen_pre[hIndex].func;
+			preHookFunc(&do_exit);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.helpscreen(do_exit);
+	}
+	if( HPMHooks.count.HP_map_helpscreen_post ) {
+		void (*postHookFunc) (bool *do_exit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_helpscreen_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_helpscreen_post[hIndex].func;
+			postHookFunc(&do_exit);
+		}
+	}
+	return;
+}
+void HP_map_versionscreen(bool do_exit) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_map_versionscreen_pre ) {
+		void (*preHookFunc) (bool *do_exit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_versionscreen_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_versionscreen_pre[hIndex].func;
+			preHookFunc(&do_exit);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.map.versionscreen(do_exit);
+	}
+	if( HPMHooks.count.HP_map_versionscreen_post ) {
+		void (*postHookFunc) (bool *do_exit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_versionscreen_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_versionscreen_post[hIndex].func;
+			postHookFunc(&do_exit);
+		}
+	}
+	return;
+}
+bool HP_map_arg_next_value(const char *option, int i, int argc) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_map_arg_next_value_pre ) {
+		bool (*preHookFunc) (const char *option, int *i, int *argc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_arg_next_value_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_map_arg_next_value_pre[hIndex].func;
+			retVal___ = preHookFunc(option, &i, &argc);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.map.arg_next_value(option, i, argc);
+	}
+	if( HPMHooks.count.HP_map_arg_next_value_post ) {
+		bool (*postHookFunc) (bool retVal___, const char *option, int *i, int *argc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_arg_next_value_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_map_arg_next_value_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, option, &i, &argc);
+		}
+	}
+	return retVal___;
+}
+/* mapit */
+struct s_mapiterator* HP_mapit_alloc(enum e_mapitflags flags, enum bl_type types) {
+	int hIndex = 0;
+	struct s_mapiterator* retVal___ = NULL;
+	if( HPMHooks.count.HP_mapit_alloc_pre ) {
+		struct s_mapiterator* (*preHookFunc) (enum e_mapitflags *flags, enum bl_type *types);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_alloc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapit_alloc_pre[hIndex].func;
+			retVal___ = preHookFunc(&flags, &types);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapit.alloc(flags, types);
+	}
+	if( HPMHooks.count.HP_mapit_alloc_post ) {
+		struct s_mapiterator* (*postHookFunc) (struct s_mapiterator* retVal___, enum e_mapitflags *flags, enum bl_type *types);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_alloc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapit_alloc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &flags, &types);
+		}
+	}
+	return retVal___;
+}
+void HP_mapit_free(struct s_mapiterator *iter) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mapit_free_pre ) {
+		void (*preHookFunc) (struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_free_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapit_free_pre[hIndex].func;
+			preHookFunc(iter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mapit.free(iter);
+	}
+	if( HPMHooks.count.HP_mapit_free_post ) {
+		void (*postHookFunc) (struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_free_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapit_free_post[hIndex].func;
+			postHookFunc(iter);
+		}
+	}
+	return;
+}
+struct block_list* HP_mapit_first(struct s_mapiterator *iter) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_mapit_first_pre ) {
+		struct block_list* (*preHookFunc) (struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_first_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapit_first_pre[hIndex].func;
+			retVal___ = preHookFunc(iter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapit.first(iter);
+	}
+	if( HPMHooks.count.HP_mapit_first_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_first_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapit_first_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, iter);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_mapit_last(struct s_mapiterator *iter) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_mapit_last_pre ) {
+		struct block_list* (*preHookFunc) (struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_last_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapit_last_pre[hIndex].func;
+			retVal___ = preHookFunc(iter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapit.last(iter);
+	}
+	if( HPMHooks.count.HP_mapit_last_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_last_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapit_last_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, iter);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_mapit_next(struct s_mapiterator *iter) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_mapit_next_pre ) {
+		struct block_list* (*preHookFunc) (struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_next_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapit_next_pre[hIndex].func;
+			retVal___ = preHookFunc(iter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapit.next(iter);
+	}
+	if( HPMHooks.count.HP_mapit_next_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_next_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapit_next_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, iter);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_mapit_prev(struct s_mapiterator *iter) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_mapit_prev_pre ) {
+		struct block_list* (*preHookFunc) (struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_prev_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapit_prev_pre[hIndex].func;
+			retVal___ = preHookFunc(iter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapit.prev(iter);
+	}
+	if( HPMHooks.count.HP_mapit_prev_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_prev_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapit_prev_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, iter);
+		}
+	}
+	return retVal___;
+}
+bool HP_mapit_exists(struct s_mapiterator *iter) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mapit_exists_pre ) {
+		bool (*preHookFunc) (struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_exists_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapit_exists_pre[hIndex].func;
+			retVal___ = preHookFunc(iter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapit.exists(iter);
+	}
+	if( HPMHooks.count.HP_mapit_exists_post ) {
+		bool (*postHookFunc) (bool retVal___, struct s_mapiterator *iter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_exists_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapit_exists_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, iter);
+		}
+	}
+	return retVal___;
+}
+/* mapreg */
+void HP_mapreg_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mapreg_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mapreg.init();
+	}
+	if( HPMHooks.count.HP_mapreg_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_mapreg_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mapreg_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mapreg.final();
+	}
+	if( HPMHooks.count.HP_mapreg_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_mapreg_readreg(int uid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mapreg_readreg_pre ) {
+		int (*preHookFunc) (int *uid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readreg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_readreg_pre[hIndex].func;
+			retVal___ = preHookFunc(&uid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapreg.readreg(uid);
+	}
+	if( HPMHooks.count.HP_mapreg_readreg_post ) {
+		int (*postHookFunc) (int retVal___, int *uid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readreg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_readreg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &uid);
+		}
+	}
+	return retVal___;
+}
+char* HP_mapreg_readregstr(int uid) {
+	int hIndex = 0;
+	char* retVal___ = NULL;
+	if( HPMHooks.count.HP_mapreg_readregstr_pre ) {
+		char* (*preHookFunc) (int *uid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readregstr_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_readregstr_pre[hIndex].func;
+			retVal___ = preHookFunc(&uid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapreg.readregstr(uid);
+	}
+	if( HPMHooks.count.HP_mapreg_readregstr_post ) {
+		char* (*postHookFunc) (char* retVal___, int *uid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readregstr_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_readregstr_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &uid);
+		}
+	}
+	return retVal___;
+}
+bool HP_mapreg_setreg(int uid, int val) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mapreg_setreg_pre ) {
+		bool (*preHookFunc) (int *uid, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setreg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_setreg_pre[hIndex].func;
+			retVal___ = preHookFunc(&uid, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapreg.setreg(uid, val);
+	}
+	if( HPMHooks.count.HP_mapreg_setreg_post ) {
+		bool (*postHookFunc) (bool retVal___, int *uid, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setreg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_setreg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &uid, &val);
+		}
+	}
+	return retVal___;
+}
+bool HP_mapreg_setregstr(int uid, const char *str) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mapreg_setregstr_pre ) {
+		bool (*preHookFunc) (int *uid, const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setregstr_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_setregstr_pre[hIndex].func;
+			retVal___ = preHookFunc(&uid, str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapreg.setregstr(uid, str);
+	}
+	if( HPMHooks.count.HP_mapreg_setregstr_post ) {
+		bool (*postHookFunc) (bool retVal___, int *uid, const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setregstr_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_setregstr_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &uid, str);
+		}
+	}
+	return retVal___;
+}
+void HP_mapreg_load(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mapreg_load_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_load_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mapreg.load();
+	}
+	if( HPMHooks.count.HP_mapreg_load_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_load_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_mapreg_save(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mapreg_save_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_save_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mapreg.save();
+	}
+	if( HPMHooks.count.HP_mapreg_save_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_save_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_mapreg_save_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mapreg_save_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_save_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapreg.save_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mapreg_save_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_save_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_mapreg_reload(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mapreg_reload_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_reload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_reload_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mapreg.reload();
+	}
+	if( HPMHooks.count.HP_mapreg_reload_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_reload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_reload_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+bool HP_mapreg_config_read(const char *w1, const char *w2) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mapreg_config_read_pre ) {
+		bool (*preHookFunc) (const char *w1, const char *w2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mapreg_config_read_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mapreg.config_read(w1, w2);
+	}
+	if( HPMHooks.count.HP_mapreg_config_read_post ) {
+		bool (*postHookFunc) (bool retVal___, const char *w1, const char *w2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mapreg_config_read_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2);
+		}
+	}
+	return retVal___;
+}
+/* mercenary */
+void HP_mercenary_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mercenary_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mercenary.init();
+	}
+	if( HPMHooks.count.HP_mercenary_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+bool HP_mercenary_class(int class_) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mercenary_class_pre ) {
+		bool (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_class_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_class_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.class(class_);
+	}
+	if( HPMHooks.count.HP_mercenary_class_post ) {
+		bool (*postHookFunc) (bool retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_class_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_class_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+struct view_data* HP_mercenary_get_viewdata(int class_) {
+	int hIndex = 0;
+	struct view_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_mercenary_get_viewdata_pre ) {
+		struct view_data* (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_viewdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_get_viewdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.get_viewdata(class_);
+	}
+	if( HPMHooks.count.HP_mercenary_get_viewdata_post ) {
+		struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_viewdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_get_viewdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_create(struct map_session_data *sd, int class_, unsigned int lifetime) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_create_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *class_, unsigned int *lifetime);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_create_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &class_, &lifetime);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.create(sd, class_, lifetime);
+	}
+	if( HPMHooks.count.HP_mercenary_create_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *class_, unsigned int *lifetime);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &class_, &lifetime);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_data_received(struct s_mercenary *merc, bool flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_data_received_pre ) {
+		int (*preHookFunc) (struct s_mercenary *merc, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_data_received_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_data_received_pre[hIndex].func;
+			retVal___ = preHookFunc(merc, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.data_received(merc, flag);
+	}
+	if( HPMHooks.count.HP_mercenary_data_received_post ) {
+		int (*postHookFunc) (int retVal___, struct s_mercenary *merc, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_data_received_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_data_received_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, merc, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_save(struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_save_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_save_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.save(md);
+	}
+	if( HPMHooks.count.HP_mercenary_save_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_save_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+void HP_mercenary_heal(struct mercenary_data *md, int hp, int sp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mercenary_heal_pre ) {
+		void (*preHookFunc) (struct mercenary_data *md, int *hp, int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_heal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_heal_pre[hIndex].func;
+			preHookFunc(md, &hp, &sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mercenary.heal(md, hp, sp);
+	}
+	if( HPMHooks.count.HP_mercenary_heal_post ) {
+		void (*postHookFunc) (struct mercenary_data *md, int *hp, int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_heal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_heal_post[hIndex].func;
+			postHookFunc(md, &hp, &sp);
+		}
+	}
+	return;
+}
+int HP_mercenary_dead(struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_dead_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_dead_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_dead_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.dead(md);
+	}
+	if( HPMHooks.count.HP_mercenary_dead_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_dead_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_dead_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_delete(struct mercenary_data *md, int reply) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_delete_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md, int *reply);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &reply);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.delete(md, reply);
+	}
+	if( HPMHooks.count.HP_mercenary_delete_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md, int *reply);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &reply);
+		}
+	}
+	return retVal___;
+}
+void HP_mercenary_contract_stop(struct mercenary_data *md) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mercenary_contract_stop_pre ) {
+		void (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_stop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_contract_stop_pre[hIndex].func;
+			preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mercenary.contract_stop(md);
+	}
+	if( HPMHooks.count.HP_mercenary_contract_stop_post ) {
+		void (*postHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_stop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_contract_stop_post[hIndex].func;
+			postHookFunc(md);
+		}
+	}
+	return;
+}
+int HP_mercenary_get_lifetime(struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_get_lifetime_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_lifetime_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_get_lifetime_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.get_lifetime(md);
+	}
+	if( HPMHooks.count.HP_mercenary_get_lifetime_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_lifetime_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_get_lifetime_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_get_guild(struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_get_guild_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_guild_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_get_guild_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.get_guild(md);
+	}
+	if( HPMHooks.count.HP_mercenary_get_guild_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_guild_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_get_guild_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_get_faith(struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_get_faith_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_faith_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_get_faith_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.get_faith(md);
+	}
+	if( HPMHooks.count.HP_mercenary_get_faith_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_faith_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_get_faith_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_set_faith(struct mercenary_data *md, int value) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_set_faith_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_faith_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_set_faith_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.set_faith(md, value);
+	}
+	if( HPMHooks.count.HP_mercenary_set_faith_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_faith_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_set_faith_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &value);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_get_calls(struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_get_calls_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_calls_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_get_calls_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.get_calls(md);
+	}
+	if( HPMHooks.count.HP_mercenary_get_calls_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_calls_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_get_calls_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_set_calls(struct mercenary_data *md, int value) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_set_calls_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_calls_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_set_calls_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.set_calls(md, value);
+	}
+	if( HPMHooks.count.HP_mercenary_set_calls_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_calls_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_set_calls_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &value);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_kills(struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_kills_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_kills_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_kills_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.kills(md);
+	}
+	if( HPMHooks.count.HP_mercenary_kills_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_kills_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_kills_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_checkskill(struct mercenary_data *md, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_checkskill_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_checkskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_checkskill_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.checkskill(md, skill_id);
+	}
+	if( HPMHooks.count.HP_mercenary_checkskill_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_checkskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_checkskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_read_db(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_read_db_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_read_db_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.read_db();
+	}
+	if( HPMHooks.count.HP_mercenary_read_db_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_read_db_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_read_skilldb(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_read_skilldb_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skilldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_read_skilldb_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.read_skilldb();
+	}
+	if( HPMHooks.count.HP_mercenary_read_skilldb_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skilldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_read_skilldb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_killbonus(struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_killbonus_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_killbonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_killbonus_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.killbonus(md);
+	}
+	if( HPMHooks.count.HP_mercenary_killbonus_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_killbonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_killbonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_search_index(int class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_search_index_pre ) {
+		int (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_search_index_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_search_index_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.search_index(class_);
+	}
+	if( HPMHooks.count.HP_mercenary_search_index_post ) {
+		int (*postHookFunc) (int retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_search_index_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_search_index_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_mercenary_contract_end_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mercenary_contract_end_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_end_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_contract_end_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.contract_end_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mercenary_contract_end_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_end_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_contract_end_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+bool HP_mercenary_read_db_sub(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mercenary_read_db_sub_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_read_db_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.read_db_sub(str, columns, current);
+	}
+	if( HPMHooks.count.HP_mercenary_read_db_sub_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_read_db_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_mercenary_read_skill_db_sub(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mercenary_read_skill_db_sub_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skill_db_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mercenary_read_skill_db_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mercenary.read_skill_db_sub(str, columns, current);
+	}
+	if( HPMHooks.count.HP_mercenary_read_skill_db_sub_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skill_db_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mercenary_read_skill_db_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+/* mob */
+int HP_mob_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.init();
+	}
+	if( HPMHooks.count.HP_mob_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_final(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_final_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_final_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.final();
+	}
+	if( HPMHooks.count.HP_mob_final_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_reload(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_reload_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_reload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_reload_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.reload();
+	}
+	if( HPMHooks.count.HP_mob_reload_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_reload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_reload_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct mob_db* HP_mob_db(int index) {
+	int hIndex = 0;
+	struct mob_db* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_db_pre ) {
+		struct mob_db* (*preHookFunc) (int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_db_pre[hIndex].func;
+			retVal___ = preHookFunc(&index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.db(index);
+	}
+	if( HPMHooks.count.HP_mob_db_post ) {
+		struct mob_db* (*postHookFunc) (struct mob_db* retVal___, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_db_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &index);
+		}
+	}
+	return retVal___;
+}
+struct mob_chat* HP_mob_chat(short id) {
+	int hIndex = 0;
+	struct mob_chat* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_chat_pre ) {
+		struct mob_chat* (*preHookFunc) (short *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_chat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_chat_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.chat(id);
+	}
+	if( HPMHooks.count.HP_mob_chat_post ) {
+		struct mob_chat* (*postHookFunc) (struct mob_chat* retVal___, short *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_chat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_chat_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_makedummymobdb(int p1) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_makedummymobdb_pre ) {
+		int (*preHookFunc) (int *p1);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_makedummymobdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_makedummymobdb_pre[hIndex].func;
+			retVal___ = preHookFunc(&p1);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.makedummymobdb(p1);
+	}
+	if( HPMHooks.count.HP_mob_makedummymobdb_post ) {
+		int (*postHookFunc) (int retVal___, int *p1);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_makedummymobdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_makedummymobdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &p1);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_spawn_guardian_sub(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_spawn_guardian_sub_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_spawn_guardian_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.spawn_guardian_sub(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mob_spawn_guardian_sub_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_spawn_guardian_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_skill_id2skill_idx(int class_, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_skill_id2skill_idx_pre ) {
+		int (*preHookFunc) (int *class_, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_id2skill_idx_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_skill_id2skill_idx_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.skill_id2skill_idx(class_, skill_id);
+	}
+	if( HPMHooks.count.HP_mob_skill_id2skill_idx_post ) {
+		int (*postHookFunc) (int retVal___, int *class_, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_id2skill_idx_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_skill_id2skill_idx_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_db_searchname(const char *str) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_db_searchname_pre ) {
+		int (*preHookFunc) (const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_db_searchname_pre[hIndex].func;
+			retVal___ = preHookFunc(str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.db_searchname(str);
+	}
+	if( HPMHooks.count.HP_mob_db_searchname_post ) {
+		int (*postHookFunc) (int retVal___, const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_db_searchname_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_db_searchname_array_sub(struct mob_db *mob, const char *str, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_db_searchname_array_sub_pre ) {
+		int (*preHookFunc) (struct mob_db *mob, const char *str, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_db_searchname_array_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(mob, str, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.db_searchname_array_sub(mob, str, flag);
+	}
+	if( HPMHooks.count.HP_mob_db_searchname_array_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_db *mob, const char *str, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_db_searchname_array_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mob, str, &flag);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_mvptomb_create(struct mob_data *md, char *killer, time_t time) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_mvptomb_create_pre ) {
+		void (*preHookFunc) (struct mob_data *md, char *killer, time_t *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_mvptomb_create_pre[hIndex].func;
+			preHookFunc(md, killer, &time);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.mvptomb_create(md, killer, time);
+	}
+	if( HPMHooks.count.HP_mob_mvptomb_create_post ) {
+		void (*postHookFunc) (struct mob_data *md, char *killer, time_t *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_mvptomb_create_post[hIndex].func;
+			postHookFunc(md, killer, &time);
+		}
+	}
+	return;
+}
+void HP_mob_mvptomb_destroy(struct mob_data *md) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_mvptomb_destroy_pre ) {
+		void (*preHookFunc) (struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_destroy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_mvptomb_destroy_pre[hIndex].func;
+			preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.mvptomb_destroy(md);
+	}
+	if( HPMHooks.count.HP_mob_mvptomb_destroy_post ) {
+		void (*postHookFunc) (struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_destroy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_mvptomb_destroy_post[hIndex].func;
+			postHookFunc(md);
+		}
+	}
+	return;
+}
+int HP_mob_db_searchname_array(struct mob_db **data, int size, const char *str, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_db_searchname_array_pre ) {
+		int (*preHookFunc) (struct mob_db **data, int *size, const char *str, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_db_searchname_array_pre[hIndex].func;
+			retVal___ = preHookFunc(data, &size, str, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.db_searchname_array(data, size, str, flag);
+	}
+	if( HPMHooks.count.HP_mob_db_searchname_array_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_db **data, int *size, const char *str, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_db_searchname_array_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, data, &size, str, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_db_checkid(const int id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_db_checkid_pre ) {
+		int (*preHookFunc) (const int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_checkid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_db_checkid_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.db_checkid(id);
+	}
+	if( HPMHooks.count.HP_mob_db_checkid_post ) {
+		int (*postHookFunc) (int retVal___, const int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_checkid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_db_checkid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+struct view_data* HP_mob_get_viewdata(int class_) {
+	int hIndex = 0;
+	struct view_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_get_viewdata_pre ) {
+		struct view_data* (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_viewdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_get_viewdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.get_viewdata(class_);
+	}
+	if( HPMHooks.count.HP_mob_get_viewdata_post ) {
+		struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_viewdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_get_viewdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_parse_dataset(struct spawn_data *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_parse_dataset_pre ) {
+		int (*preHookFunc) (struct spawn_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_dataset_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_parse_dataset_pre[hIndex].func;
+			retVal___ = preHookFunc(data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.parse_dataset(data);
+	}
+	if( HPMHooks.count.HP_mob_parse_dataset_post ) {
+		int (*postHookFunc) (int retVal___, struct spawn_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_dataset_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_parse_dataset_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, data);
+		}
+	}
+	return retVal___;
+}
+struct mob_data* HP_mob_spawn_dataset(struct spawn_data *data) {
+	int hIndex = 0;
+	struct mob_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_spawn_dataset_pre ) {
+		struct mob_data* (*preHookFunc) (struct spawn_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_dataset_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_spawn_dataset_pre[hIndex].func;
+			retVal___ = preHookFunc(data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.spawn_dataset(data);
+	}
+	if( HPMHooks.count.HP_mob_spawn_dataset_post ) {
+		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct spawn_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_dataset_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_spawn_dataset_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, data);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_get_random_id(int type, int flag, int lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_get_random_id_pre ) {
+		int (*preHookFunc) (int *type, int *flag, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_random_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_get_random_id_pre[hIndex].func;
+			retVal___ = preHookFunc(&type, &flag, &lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.get_random_id(type, flag, lv);
+	}
+	if( HPMHooks.count.HP_mob_get_random_id_post ) {
+		int (*postHookFunc) (int retVal___, int *type, int *flag, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_random_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_get_random_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &type, &flag, &lv);
+		}
+	}
+	return retVal___;
+}
+bool HP_mob_ksprotected(struct block_list *src, struct block_list *target) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_ksprotected_pre ) {
+		bool (*preHookFunc) (struct block_list *src, struct block_list *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ksprotected_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_ksprotected_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.ksprotected(src, target);
+	}
+	if( HPMHooks.count.HP_mob_ksprotected_post ) {
+		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ksprotected_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_ksprotected_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target);
+		}
+	}
+	return retVal___;
+}
+struct mob_data* HP_mob_once_spawn_sub(struct block_list *bl, int16 m, int16 x, int16 y, const char *mobname, int class_, const char *event, unsigned int size, unsigned int ai) {
+	int hIndex = 0;
+	struct mob_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_once_spawn_sub_pre ) {
+		struct mob_data* (*preHookFunc) (struct block_list *bl, int16 *m, int16 *x, int16 *y, const char *mobname, int *class_, const char *event, unsigned int *size, unsigned int *ai);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_once_spawn_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &m, &x, &y, mobname, &class_, event, &size, &ai);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.once_spawn_sub(bl, m, x, y, mobname, class_, event, size, ai);
+	}
+	if( HPMHooks.count.HP_mob_once_spawn_sub_post ) {
+		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct block_list *bl, int16 *m, int16 *x, int16 *y, const char *mobname, int *class_, const char *event, unsigned int *size, unsigned int *ai);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_once_spawn_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &m, &x, &y, mobname, &class_, event, &size, &ai);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_once_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_once_spawn_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x, int16 *y, const char *mobname, int *class_, int *amount, const char *event, unsigned int *size, unsigned int *ai);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_once_spawn_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &m, &x, &y, mobname, &class_, &amount, event, &size, &ai);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.once_spawn(sd, m, x, y, mobname, class_, amount, event, size, ai);
+	}
+	if( HPMHooks.count.HP_mob_once_spawn_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x, int16 *y, const char *mobname, int *class_, int *amount, const char *event, unsigned int *size, unsigned int *ai);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_once_spawn_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &m, &x, &y, mobname, &class_, &amount, event, &size, &ai);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_once_spawn_area(struct map_session_data *sd, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_once_spawn_area_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, const char *mobname, int *class_, int *amount, const char *event, unsigned int *size, unsigned int *ai);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_area_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_once_spawn_area_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &m, &x0, &y0, &x1, &y1, mobname, &class_, &amount, event, &size, &ai);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.once_spawn_area(sd, m, x0, y0, x1, y1, mobname, class_, amount, event, size, ai);
+	}
+	if( HPMHooks.count.HP_mob_once_spawn_area_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, const char *mobname, int *class_, int *amount, const char *event, unsigned int *size, unsigned int *ai);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_area_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_once_spawn_area_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &m, &x0, &y0, &x1, &y1, mobname, &class_, &amount, event, &size, &ai);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_spawn_guardian(const char *mapname, short x, short y, const char *mobname, int class_, const char *event, int guardian, bool has_index) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_spawn_guardian_pre ) {
+		int (*preHookFunc) (const char *mapname, short *x, short *y, const char *mobname, int *class_, const char *event, int *guardian, bool *has_index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_spawn_guardian_pre[hIndex].func;
+			retVal___ = preHookFunc(mapname, &x, &y, mobname, &class_, event, &guardian, &has_index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.spawn_guardian(mapname, x, y, mobname, class_, event, guardian, has_index);
+	}
+	if( HPMHooks.count.HP_mob_spawn_guardian_post ) {
+		int (*postHookFunc) (int retVal___, const char *mapname, short *x, short *y, const char *mobname, int *class_, const char *event, int *guardian, bool *has_index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_spawn_guardian_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mapname, &x, &y, mobname, &class_, event, &guardian, &has_index);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_spawn_bg(const char *mapname, short x, short y, const char *mobname, int class_, const char *event, unsigned int bg_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_spawn_bg_pre ) {
+		int (*preHookFunc) (const char *mapname, short *x, short *y, const char *mobname, int *class_, const char *event, unsigned int *bg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_bg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_spawn_bg_pre[hIndex].func;
+			retVal___ = preHookFunc(mapname, &x, &y, mobname, &class_, event, &bg_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.spawn_bg(mapname, x, y, mobname, class_, event, bg_id);
+	}
+	if( HPMHooks.count.HP_mob_spawn_bg_post ) {
+		int (*postHookFunc) (int retVal___, const char *mapname, short *x, short *y, const char *mobname, int *class_, const char *event, unsigned int *bg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_bg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_spawn_bg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, mapname, &x, &y, mobname, &class_, event, &bg_id);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_can_reach(struct mob_data *md, struct block_list *bl, int range, int state) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_can_reach_pre ) {
+		int (*preHookFunc) (struct mob_data *md, struct block_list *bl, int *range, int *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_reach_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_can_reach_pre[hIndex].func;
+			retVal___ = preHookFunc(md, bl, &range, &state);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.can_reach(md, bl, range, state);
+	}
+	if( HPMHooks.count.HP_mob_can_reach_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *bl, int *range, int *state);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_reach_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_can_reach_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, bl, &range, &state);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_linksearch(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_linksearch_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_linksearch_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_linksearch_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.linksearch(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_linksearch_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_linksearch_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_linksearch_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_delayspawn(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_delayspawn_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_delayspawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_delayspawn_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.delayspawn(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mob_delayspawn_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_delayspawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_delayspawn_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_setdelayspawn(struct mob_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_setdelayspawn_pre ) {
+		int (*preHookFunc) (struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdelayspawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_setdelayspawn_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.setdelayspawn(md);
+	}
+	if( HPMHooks.count.HP_mob_setdelayspawn_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdelayspawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_setdelayspawn_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_count_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_count_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_count_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_count_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.count_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_count_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_count_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_count_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_spawn(struct mob_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_spawn_pre ) {
+		int (*preHookFunc) (struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_spawn_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.spawn(md);
+	}
+	if( HPMHooks.count.HP_mob_spawn_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_spawn_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_can_changetarget(struct mob_data *md, struct block_list *target, int mode) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_can_changetarget_pre ) {
+		int (*preHookFunc) (struct mob_data *md, struct block_list *target, int *mode);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_changetarget_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_can_changetarget_pre[hIndex].func;
+			retVal___ = preHookFunc(md, target, &mode);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.can_changetarget(md, target, mode);
+	}
+	if( HPMHooks.count.HP_mob_can_changetarget_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *target, int *mode);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_changetarget_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_can_changetarget_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, target, &mode);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_target(struct mob_data *md, struct block_list *bl, int dist) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_target_pre ) {
+		int (*preHookFunc) (struct mob_data *md, struct block_list *bl, int *dist);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_target_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_target_pre[hIndex].func;
+			retVal___ = preHookFunc(md, bl, &dist);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.target(md, bl, dist);
+	}
+	if( HPMHooks.count.HP_mob_target_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *bl, int *dist);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_target_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_target_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, bl, &dist);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_sub_hard_activesearch(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_sub_hard_activesearch_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_activesearch_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_activesearch_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.ai_sub_hard_activesearch(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_hard_activesearch_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_activesearch_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_activesearch_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_sub_hard_changechase(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_sub_hard_changechase_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_changechase_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_changechase_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.ai_sub_hard_changechase(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_hard_changechase_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_changechase_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_changechase_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_sub_hard_bg_ally(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_bg_ally_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.ai_sub_hard_bg_ally(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_bg_ally_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_sub_hard_lootsearch(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_lootsearch_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.ai_sub_hard_lootsearch(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_lootsearch_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_warpchase_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_warpchase_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_warpchase_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.warpchase_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_warpchase_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_warpchase_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_sub_hard_slavemob(struct mob_data *md, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_sub_hard_slavemob_pre ) {
+		int (*preHookFunc) (struct mob_data *md, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_slavemob_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_slavemob_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.ai_sub_hard_slavemob(md, tick);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_hard_slavemob_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_slavemob_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_slavemob_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_unlocktarget(struct mob_data *md, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_unlocktarget_pre ) {
+		int (*preHookFunc) (struct mob_data *md, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_unlocktarget_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_unlocktarget_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.unlocktarget(md, tick);
+	}
+	if( HPMHooks.count.HP_mob_unlocktarget_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_unlocktarget_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_unlocktarget_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_randomwalk(struct mob_data *md, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_randomwalk_pre ) {
+		int (*preHookFunc) (struct mob_data *md, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_randomwalk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_randomwalk_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.randomwalk(md, tick);
+	}
+	if( HPMHooks.count.HP_mob_randomwalk_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_randomwalk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_randomwalk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_warpchase(struct mob_data *md, struct block_list *target) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_warpchase_pre ) {
+		int (*preHookFunc) (struct mob_data *md, struct block_list *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_warpchase_pre[hIndex].func;
+			retVal___ = preHookFunc(md, target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.warpchase(md, target);
+	}
+	if( HPMHooks.count.HP_mob_warpchase_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_warpchase_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, target);
+		}
+	}
+	return retVal___;
+}
+bool HP_mob_ai_sub_hard(struct mob_data *md, unsigned int tick) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_ai_sub_hard_pre ) {
+		bool (*preHookFunc) (struct mob_data *md, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.ai_sub_hard(md, tick);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_hard_post ) {
+		bool (*postHookFunc) (bool retVal___, struct mob_data *md, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_sub_hard_timer(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_sub_hard_timer_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_timer_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.ai_sub_hard_timer(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_hard_timer_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_timer_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_sub_foreachclient_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_foreachclient_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_foreachclient_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.ai_sub_foreachclient(sd, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_foreachclient_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_foreachclient_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_foreachclient_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_sub_lazy(struct mob_data *md, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_sub_lazy_pre ) {
+		int (*preHookFunc) (struct mob_data *md, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_lazy_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_mob_ai_sub_lazy_pre[hIndex].func;
+			retVal___ = preHookFunc(md, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.mob.ai_sub_lazy(md, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_mob_ai_sub_lazy_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_lazy_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_mob_ai_sub_lazy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_lazy(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_lazy_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_lazy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_ai_lazy_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.ai_lazy(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mob_ai_lazy_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_lazy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_ai_lazy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_ai_hard(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_ai_hard_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_hard_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_ai_hard_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.ai_hard(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mob_ai_hard_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_hard_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_ai_hard_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+struct item_drop* HP_mob_setdropitem(int nameid, int qty, struct item_data *data) {
+	int hIndex = 0;
+	struct item_drop* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_setdropitem_pre ) {
+		struct item_drop* (*preHookFunc) (int *nameid, int *qty, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdropitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_setdropitem_pre[hIndex].func;
+			retVal___ = preHookFunc(&nameid, &qty, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.setdropitem(nameid, qty, data);
+	}
+	if( HPMHooks.count.HP_mob_setdropitem_post ) {
+		struct item_drop* (*postHookFunc) (struct item_drop* retVal___, int *nameid, int *qty, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdropitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_setdropitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &nameid, &qty, data);
+		}
+	}
+	return retVal___;
+}
+struct item_drop* HP_mob_setlootitem(struct item *item) {
+	int hIndex = 0;
+	struct item_drop* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_setlootitem_pre ) {
+		struct item_drop* (*preHookFunc) (struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setlootitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_setlootitem_pre[hIndex].func;
+			retVal___ = preHookFunc(item);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.setlootitem(item);
+	}
+	if( HPMHooks.count.HP_mob_setlootitem_post ) {
+		struct item_drop* (*postHookFunc) (struct item_drop* retVal___, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setlootitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_setlootitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, item);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_delay_item_drop(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_delay_item_drop_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_delay_item_drop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_delay_item_drop_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.delay_item_drop(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mob_delay_item_drop_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_delay_item_drop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_delay_item_drop_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_item_drop(struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int loot, int drop_rate, unsigned short flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_item_drop_pre ) {
+		void (*preHookFunc) (struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int *loot, int *drop_rate, unsigned short *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_drop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_item_drop_pre[hIndex].func;
+			preHookFunc(md, dlist, ditem, &loot, &drop_rate, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.item_drop(md, dlist, ditem, loot, drop_rate, flag);
+	}
+	if( HPMHooks.count.HP_mob_item_drop_post ) {
+		void (*postHookFunc) (struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int *loot, int *drop_rate, unsigned short *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_drop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_item_drop_post[hIndex].func;
+			postHookFunc(md, dlist, ditem, &loot, &drop_rate, &flag);
+		}
+	}
+	return;
+}
+int HP_mob_timer_delete(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_timer_delete_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_timer_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_timer_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.timer_delete(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mob_timer_delete_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_timer_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_timer_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_deleteslave_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_deleteslave_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_deleteslave_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.deleteslave_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_deleteslave_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_deleteslave_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_deleteslave(struct mob_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_deleteslave_pre ) {
+		int (*preHookFunc) (struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_deleteslave_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.deleteslave(md);
+	}
+	if( HPMHooks.count.HP_mob_deleteslave_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_deleteslave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_respawn(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_respawn_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_respawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_respawn_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.respawn(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_mob_respawn_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_respawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_respawn_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_log_damage(struct mob_data *md, struct block_list *src, int damage) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_log_damage_pre ) {
+		void (*preHookFunc) (struct mob_data *md, struct block_list *src, int *damage);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_log_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_log_damage_pre[hIndex].func;
+			preHookFunc(md, src, &damage);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.log_damage(md, src, damage);
+	}
+	if( HPMHooks.count.HP_mob_log_damage_post ) {
+		void (*postHookFunc) (struct mob_data *md, struct block_list *src, int *damage);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_log_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_log_damage_post[hIndex].func;
+			postHookFunc(md, src, &damage);
+		}
+	}
+	return;
+}
+void HP_mob_damage(struct mob_data *md, struct block_list *src, int damage) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_damage_pre ) {
+		void (*preHookFunc) (struct mob_data *md, struct block_list *src, int *damage);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_damage_pre[hIndex].func;
+			preHookFunc(md, src, &damage);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.damage(md, src, damage);
+	}
+	if( HPMHooks.count.HP_mob_damage_post ) {
+		void (*postHookFunc) (struct mob_data *md, struct block_list *src, int *damage);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_damage_post[hIndex].func;
+			postHookFunc(md, src, &damage);
+		}
+	}
+	return;
+}
+int HP_mob_dead(struct mob_data *md, struct block_list *src, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_dead_pre ) {
+		int (*preHookFunc) (struct mob_data *md, struct block_list *src, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_dead_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_dead_pre[hIndex].func;
+			retVal___ = preHookFunc(md, src, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.dead(md, src, type);
+	}
+	if( HPMHooks.count.HP_mob_dead_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *src, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_dead_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_dead_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, src, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_revive(struct mob_data *md, unsigned int hp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_revive_pre ) {
+		void (*preHookFunc) (struct mob_data *md, unsigned int *hp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_revive_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_revive_pre[hIndex].func;
+			preHookFunc(md, &hp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.revive(md, hp);
+	}
+	if( HPMHooks.count.HP_mob_revive_post ) {
+		void (*postHookFunc) (struct mob_data *md, unsigned int *hp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_revive_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_revive_post[hIndex].func;
+			postHookFunc(md, &hp);
+		}
+	}
+	return;
+}
+int HP_mob_guardian_guildchange(struct mob_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_guardian_guildchange_pre ) {
+		int (*preHookFunc) (struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_guardian_guildchange_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_guardian_guildchange_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.guardian_guildchange(md);
+	}
+	if( HPMHooks.count.HP_mob_guardian_guildchange_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_guardian_guildchange_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_guardian_guildchange_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_random_class(int *value, size_t count) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_random_class_pre ) {
+		int (*preHookFunc) (int *value, size_t *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_random_class_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_random_class_pre[hIndex].func;
+			retVal___ = preHookFunc(value, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.random_class(value, count);
+	}
+	if( HPMHooks.count.HP_mob_random_class_post ) {
+		int (*postHookFunc) (int retVal___, int *value, size_t *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_random_class_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_random_class_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, value, &count);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_class_change(struct mob_data *md, int class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_class_change_pre ) {
+		int (*preHookFunc) (struct mob_data *md, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_class_change_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_class_change_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.class_change(md, class_);
+	}
+	if( HPMHooks.count.HP_mob_class_change_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_class_change_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_class_change_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &class_);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_heal(struct mob_data *md, unsigned int heal) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_heal_pre ) {
+		void (*preHookFunc) (struct mob_data *md, unsigned int *heal);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_heal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_heal_pre[hIndex].func;
+			preHookFunc(md, &heal);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.heal(md, heal);
+	}
+	if( HPMHooks.count.HP_mob_heal_post ) {
+		void (*postHookFunc) (struct mob_data *md, unsigned int *heal);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_heal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_heal_post[hIndex].func;
+			postHookFunc(md, &heal);
+		}
+	}
+	return;
+}
+int HP_mob_warpslave_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_warpslave_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_warpslave_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.warpslave_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_warpslave_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_warpslave_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_warpslave(struct block_list *bl, int range) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_warpslave_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *range);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_warpslave_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &range);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.warpslave(bl, range);
+	}
+	if( HPMHooks.count.HP_mob_warpslave_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *range);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_warpslave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &range);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_countslave_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_countslave_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_countslave_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.countslave_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_countslave_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_countslave_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_countslave(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_countslave_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_countslave_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.countslave(bl);
+	}
+	if( HPMHooks.count.HP_mob_countslave_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_countslave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_summonslave(struct mob_data *md2, int *value, int amount, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_summonslave_pre ) {
+		int (*preHookFunc) (struct mob_data *md2, int *value, int *amount, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_summonslave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_summonslave_pre[hIndex].func;
+			retVal___ = preHookFunc(md2, value, &amount, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.summonslave(md2, value, amount, skill_id);
+	}
+	if( HPMHooks.count.HP_mob_summonslave_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md2, int *value, int *amount, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_summonslave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_summonslave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md2, value, &amount, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_getfriendhprate_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_getfriendhprate_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_getfriendhprate_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.getfriendhprate_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_getfriendhprate_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_getfriendhprate_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_mob_getfriendhprate(struct mob_data *md, int min_rate, int max_rate) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_getfriendhprate_pre ) {
+		struct block_list* (*preHookFunc) (struct mob_data *md, int *min_rate, int *max_rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_getfriendhprate_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &min_rate, &max_rate);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.getfriendhprate(md, min_rate, max_rate);
+	}
+	if( HPMHooks.count.HP_mob_getfriendhprate_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct mob_data *md, int *min_rate, int *max_rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_getfriendhprate_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &min_rate, &max_rate);
+		}
+	}
+	return retVal___;
+}
+struct block_list* HP_mob_getmasterhpltmaxrate(struct mob_data *md, int rate) {
+	int hIndex = 0;
+	struct block_list* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_getmasterhpltmaxrate_pre ) {
+		struct block_list* (*preHookFunc) (struct mob_data *md, int *rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getmasterhpltmaxrate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_getmasterhpltmaxrate_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &rate);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.getmasterhpltmaxrate(md, rate);
+	}
+	if( HPMHooks.count.HP_mob_getmasterhpltmaxrate_post ) {
+		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct mob_data *md, int *rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getmasterhpltmaxrate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_getmasterhpltmaxrate_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &rate);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_getfriendstatus_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_getfriendstatus_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_mob_getfriendstatus_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.mob.getfriendstatus_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_mob_getfriendstatus_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_mob_getfriendstatus_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+struct mob_data* HP_mob_getfriendstatus(struct mob_data *md, int cond1, int cond2) {
+	int hIndex = 0;
+	struct mob_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_mob_getfriendstatus_pre ) {
+		struct mob_data* (*preHookFunc) (struct mob_data *md, int *cond1, int *cond2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_getfriendstatus_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &cond1, &cond2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.getfriendstatus(md, cond1, cond2);
+	}
+	if( HPMHooks.count.HP_mob_getfriendstatus_post ) {
+		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct mob_data *md, int *cond1, int *cond2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_getfriendstatus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &cond1, &cond2);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_skill_use(struct mob_data *md, unsigned int tick, int event) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_skill_use_pre ) {
+		int (*preHookFunc) (struct mob_data *md, unsigned int *tick, int *event);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_use_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_skill_use_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &tick, &event);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.skill_use(md, tick, event);
+	}
+	if( HPMHooks.count.HP_mob_skill_use_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, unsigned int *tick, int *event);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_use_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_skill_use_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &tick, &event);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_skill_event(struct mob_data *md, struct block_list *src, unsigned int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_skill_event_pre ) {
+		int (*preHookFunc) (struct mob_data *md, struct block_list *src, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_skill_event_pre[hIndex].func;
+			retVal___ = preHookFunc(md, src, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.skill_event(md, src, tick, flag);
+	}
+	if( HPMHooks.count.HP_mob_skill_event_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *src, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_skill_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, src, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_is_clone(int class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_is_clone_pre ) {
+		int (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_is_clone_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_is_clone_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.is_clone(class_);
+	}
+	if( HPMHooks.count.HP_mob_is_clone_post ) {
+		int (*postHookFunc) (int retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_is_clone_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_is_clone_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, const char *event, int master_id, int mode, int flag, unsigned int duration) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_clone_spawn_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x, int16 *y, const char *event, int *master_id, int *mode, int *flag, unsigned int *duration);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_spawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_clone_spawn_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &m, &x, &y, event, &master_id, &mode, &flag, &duration);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.clone_spawn(sd, m, x, y, event, master_id, mode, flag, duration);
+	}
+	if( HPMHooks.count.HP_mob_clone_spawn_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x, int16 *y, const char *event, int *master_id, int *mode, int *flag, unsigned int *duration);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_spawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_clone_spawn_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &m, &x, &y, event, &master_id, &mode, &flag, &duration);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_clone_delete(struct mob_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_clone_delete_pre ) {
+		int (*preHookFunc) (struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_clone_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.clone_delete(md);
+	}
+	if( HPMHooks.count.HP_mob_clone_delete_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_clone_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_mob_drop_adjust(int baserate, int rate_adjust, unsigned short rate_min, unsigned short rate_max) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_mob_drop_adjust_pre ) {
+		unsigned int (*preHookFunc) (int *baserate, int *rate_adjust, unsigned short *rate_min, unsigned short *rate_max);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_drop_adjust_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_drop_adjust_pre[hIndex].func;
+			retVal___ = preHookFunc(&baserate, &rate_adjust, &rate_min, &rate_max);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.drop_adjust(baserate, rate_adjust, rate_min, rate_max);
+	}
+	if( HPMHooks.count.HP_mob_drop_adjust_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, int *baserate, int *rate_adjust, unsigned short *rate_min, unsigned short *rate_max);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_drop_adjust_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_drop_adjust_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &baserate, &rate_adjust, &rate_min, &rate_max);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_item_dropratio_adjust(int nameid, int mob_id, int *rate_adjust) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_item_dropratio_adjust_pre ) {
+		void (*preHookFunc) (int *nameid, int *mob_id, int *rate_adjust);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_dropratio_adjust_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_item_dropratio_adjust_pre[hIndex].func;
+			preHookFunc(&nameid, &mob_id, rate_adjust);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.item_dropratio_adjust(nameid, mob_id, rate_adjust);
+	}
+	if( HPMHooks.count.HP_mob_item_dropratio_adjust_post ) {
+		void (*postHookFunc) (int *nameid, int *mob_id, int *rate_adjust);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_dropratio_adjust_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_item_dropratio_adjust_post[hIndex].func;
+			postHookFunc(&nameid, &mob_id, rate_adjust);
+		}
+	}
+	return;
+}
+bool HP_mob_parse_dbrow(char **str) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_parse_dbrow_pre ) {
+		bool (*preHookFunc) (char **str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_dbrow_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_parse_dbrow_pre[hIndex].func;
+			retVal___ = preHookFunc(str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.parse_dbrow(str);
+	}
+	if( HPMHooks.count.HP_mob_parse_dbrow_post ) {
+		bool (*postHookFunc) (bool retVal___, char **str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_dbrow_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_parse_dbrow_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str);
+		}
+	}
+	return retVal___;
+}
+bool HP_mob_readdb_sub(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_readdb_sub_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_readdb_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.readdb_sub(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_mob_readdb_sub_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_readdb_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_readdb(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_readdb_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_readdb_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.readdb();
+	}
+	if( HPMHooks.count.HP_mob_readdb_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_readdb_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_mob_read_sqldb(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_read_sqldb_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_sqldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_read_sqldb_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.read_sqldb();
+	}
+	if( HPMHooks.count.HP_mob_read_sqldb_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_sqldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_read_sqldb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+bool HP_mob_readdb_mobavail(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_readdb_mobavail_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_mobavail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_readdb_mobavail_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.readdb_mobavail(str, columns, current);
+	}
+	if( HPMHooks.count.HP_mob_readdb_mobavail_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_mobavail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_readdb_mobavail_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+int HP_mob_read_randommonster(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_read_randommonster_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_randommonster_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_read_randommonster_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.read_randommonster();
+	}
+	if( HPMHooks.count.HP_mob_read_randommonster_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_randommonster_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_read_randommonster_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+bool HP_mob_parse_row_chatdb(char **str, const char *source, int line, int *last_msg_id) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_parse_row_chatdb_pre ) {
+		bool (*preHookFunc) (char **str, const char *source, int *line, int *last_msg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_chatdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_parse_row_chatdb_pre[hIndex].func;
+			retVal___ = preHookFunc(str, source, &line, last_msg_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.parse_row_chatdb(str, source, line, last_msg_id);
+	}
+	if( HPMHooks.count.HP_mob_parse_row_chatdb_post ) {
+		bool (*postHookFunc) (bool retVal___, char **str, const char *source, int *line, int *last_msg_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_chatdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_parse_row_chatdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, source, &line, last_msg_id);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_readchatdb(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_readchatdb_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readchatdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_readchatdb_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.readchatdb();
+	}
+	if( HPMHooks.count.HP_mob_readchatdb_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readchatdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_readchatdb_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+bool HP_mob_parse_row_mobskilldb(char **str, int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_parse_row_mobskilldb_pre ) {
+		bool (*preHookFunc) (char **str, int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_mobskilldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_parse_row_mobskilldb_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.parse_row_mobskilldb(str, columns, current);
+	}
+	if( HPMHooks.count.HP_mob_parse_row_mobskilldb_post ) {
+		bool (*postHookFunc) (bool retVal___, char **str, int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_mobskilldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_parse_row_mobskilldb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_readskilldb(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_readskilldb_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readskilldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_readskilldb_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.readskilldb();
+	}
+	if( HPMHooks.count.HP_mob_readskilldb_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readskilldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_readskilldb_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_mob_read_sqlskilldb(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_mob_read_sqlskilldb_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_sqlskilldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_read_sqlskilldb_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.read_sqlskilldb();
+	}
+	if( HPMHooks.count.HP_mob_read_sqlskilldb_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_sqlskilldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_read_sqlskilldb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+bool HP_mob_readdb_race2(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_readdb_race2_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_race2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_readdb_race2_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.readdb_race2(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_mob_readdb_race2_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_race2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_readdb_race2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_mob_readdb_itemratio(char *str[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_mob_readdb_itemratio_pre ) {
+		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_itemratio_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_readdb_itemratio_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.mob.readdb_itemratio(str, columns, current);
+	}
+	if( HPMHooks.count.HP_mob_readdb_itemratio_post ) {
+		bool (*postHookFunc) (bool retVal___, char *str[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_itemratio_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_readdb_itemratio_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+void HP_mob_load(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_load_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_load_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_load_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.load();
+	}
+	if( HPMHooks.count.HP_mob_load_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_load_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_load_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_mob_clear_spawninfo(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_mob_clear_spawninfo_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clear_spawninfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_mob_clear_spawninfo_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.mob.clear_spawninfo();
+	}
+	if( HPMHooks.count.HP_mob_clear_spawninfo_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clear_spawninfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_mob_clear_spawninfo_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+/* npc */
+int HP_npc_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.init();
+	}
+	if( HPMHooks.count.HP_npc_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_final(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_final_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_final_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.final();
+	}
+	if( HPMHooks.count.HP_npc_final_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_get_new_npc_id(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_get_new_npc_id_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_get_new_npc_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_get_new_npc_id_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.get_new_npc_id();
+	}
+	if( HPMHooks.count.HP_npc_get_new_npc_id_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_get_new_npc_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_get_new_npc_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+struct view_data* HP_npc_get_viewdata(int class_) {
+	int hIndex = 0;
+	struct view_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_get_viewdata_pre ) {
+		struct view_data* (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_get_viewdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_get_viewdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.get_viewdata(class_);
+	}
+	if( HPMHooks.count.HP_npc_get_viewdata_post ) {
+		struct view_data* (*postHookFunc) (struct view_data* retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_get_viewdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_get_viewdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_isnear_sub(struct block_list *bl, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_isnear_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_sub_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_npc_isnear_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.npc.isnear_sub(bl, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_npc_isnear_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_sub_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_npc_isnear_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+bool HP_npc_isnear(struct block_list *bl) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_npc_isnear_pre ) {
+		bool (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_isnear_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.isnear(bl);
+	}
+	if( HPMHooks.count.HP_npc_isnear_post ) {
+		bool (*postHookFunc) (bool retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_isnear_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_ontouch_event(struct map_session_data *sd, struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_ontouch_event_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ontouch_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_ontouch_event_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.ontouch_event(sd, nd);
+	}
+	if( HPMHooks.count.HP_npc_ontouch_event_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ontouch_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_ontouch_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_ontouch2_event(struct map_session_data *sd, struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_ontouch2_event_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ontouch2_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_ontouch2_event_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.ontouch2_event(sd, nd);
+	}
+	if( HPMHooks.count.HP_npc_ontouch2_event_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ontouch2_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_ontouch2_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_enable_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_enable_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_npc_enable_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.npc.enable_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_npc_enable_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_npc_enable_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_enable(const char *name, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_enable_pre ) {
+		int (*preHookFunc) (const char *name, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_enable_pre[hIndex].func;
+			retVal___ = preHookFunc(name, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.enable(name, flag);
+	}
+	if( HPMHooks.count.HP_npc_enable_post ) {
+		int (*postHookFunc) (int retVal___, const char *name, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_enable_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, &flag);
+		}
+	}
+	return retVal___;
+}
+struct npc_data* HP_npc_name2id(const char *name) {
+	int hIndex = 0;
+	struct npc_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_name2id_pre ) {
+		struct npc_data* (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_name2id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_name2id_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.name2id(name);
+	}
+	if( HPMHooks.count.HP_npc_name2id_post ) {
+		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_name2id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_name2id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_event_dequeue(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_event_dequeue_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_dequeue_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_dequeue_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.event_dequeue(sd);
+	}
+	if( HPMHooks.count.HP_npc_event_dequeue_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_dequeue_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_dequeue_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+DBData HP_npc_event_export_create(DBKey key, va_list args) {
+	int hIndex = 0;
+	DBData retVal___;
+	memset(&retVal___, '\0', sizeof(DBData));
+	if( HPMHooks.count.HP_npc_event_export_create_pre ) {
+		DBData (*preHookFunc) (DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_create_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_npc_event_export_create_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.npc.event_export_create(key, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_npc_event_export_create_post ) {
+		DBData (*postHookFunc) (DBData retVal___, DBKey *key, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_create_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_npc_event_export_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_event_export(struct npc_data *nd, int i) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_event_export_pre ) {
+		int (*preHookFunc) (struct npc_data *nd, int *i);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_export_pre[hIndex].func;
+			retVal___ = preHookFunc(nd, &i);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.event_export(nd, i);
+	}
+	if( HPMHooks.count.HP_npc_event_export_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd, int *i);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_export_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd, &i);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_event_sub(struct map_session_data *sd, struct event_data *ev, const char *eventname) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_event_sub_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct event_data *ev, const char *eventname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, ev, eventname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.event_sub(sd, ev, eventname);
+	}
+	if( HPMHooks.count.HP_npc_event_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct event_data *ev, const char *eventname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, ev, eventname);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_event_doall_sub(void *key, void *data, va_list ap) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_event_doall_sub_pre ) {
+		void (*preHookFunc) (void *key, void *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_npc_event_doall_sub_pre[hIndex].func;
+			preHookFunc(key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		HPMHooks.source.npc.event_doall_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_npc_event_doall_sub_post ) {
+		void (*postHookFunc) (void *key, void *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_npc_event_doall_sub_post[hIndex].func;
+			postHookFunc(key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return;
+}
+int HP_npc_event_do(const char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_event_do_pre ) {
+		int (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_do_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.event_do(name);
+	}
+	if( HPMHooks.count.HP_npc_event_do_post ) {
+		int (*postHookFunc) (int retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_do_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_event_doall_id(const char *name, int rid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_event_doall_id_pre ) {
+		int (*preHookFunc) (const char *name, int *rid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_doall_id_pre[hIndex].func;
+			retVal___ = preHookFunc(name, &rid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.event_doall_id(name, rid);
+	}
+	if( HPMHooks.count.HP_npc_event_doall_id_post ) {
+		int (*postHookFunc) (int retVal___, const char *name, int *rid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_doall_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, &rid);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_event_doall(const char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_event_doall_pre ) {
+		int (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_doall_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.event_doall(name);
+	}
+	if( HPMHooks.count.HP_npc_event_doall_post ) {
+		int (*postHookFunc) (int retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_doall_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_event_do_clock(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_event_do_clock_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_clock_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_do_clock_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.event_do_clock(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_npc_event_do_clock_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_clock_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_do_clock_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_event_do_oninit(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_event_do_oninit_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_oninit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_do_oninit_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.event_do_oninit();
+	}
+	if( HPMHooks.count.HP_npc_event_do_oninit_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_oninit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_do_oninit_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_npc_timerevent_export(struct npc_data *nd, int i) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_timerevent_export_pre ) {
+		int (*preHookFunc) (struct npc_data *nd, int *i);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_export_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_timerevent_export_pre[hIndex].func;
+			retVal___ = preHookFunc(nd, &i);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.timerevent_export(nd, i);
+	}
+	if( HPMHooks.count.HP_npc_timerevent_export_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd, int *i);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_export_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_timerevent_export_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd, &i);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_timerevent(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_timerevent_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_timerevent_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.timerevent(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_npc_timerevent_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_timerevent_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_timerevent_start(struct npc_data *nd, int rid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_timerevent_start_pre ) {
+		int (*preHookFunc) (struct npc_data *nd, int *rid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_start_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_timerevent_start_pre[hIndex].func;
+			retVal___ = preHookFunc(nd, &rid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.timerevent_start(nd, rid);
+	}
+	if( HPMHooks.count.HP_npc_timerevent_start_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd, int *rid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_start_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_timerevent_start_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd, &rid);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_timerevent_stop(struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_timerevent_stop_pre ) {
+		int (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_stop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_timerevent_stop_pre[hIndex].func;
+			retVal___ = preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.timerevent_stop(nd);
+	}
+	if( HPMHooks.count.HP_npc_timerevent_stop_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_stop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_timerevent_stop_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_timerevent_quit(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_timerevent_quit_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_quit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_timerevent_quit_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.timerevent_quit(sd);
+	}
+	if( HPMHooks.count.HP_npc_timerevent_quit_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_quit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_timerevent_quit_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_npc_gettimerevent_tick(struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_gettimerevent_tick_pre ) {
+		int (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_gettimerevent_tick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_gettimerevent_tick_pre[hIndex].func;
+			retVal___ = preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.gettimerevent_tick(nd);
+	}
+	if( HPMHooks.count.HP_npc_gettimerevent_tick_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_gettimerevent_tick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_gettimerevent_tick_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_settimerevent_tick(struct npc_data *nd, int newtimer) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_settimerevent_tick_pre ) {
+		int (*preHookFunc) (struct npc_data *nd, int *newtimer);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_settimerevent_tick_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_settimerevent_tick_pre[hIndex].func;
+			retVal___ = preHookFunc(nd, &newtimer);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.settimerevent_tick(nd, newtimer);
+	}
+	if( HPMHooks.count.HP_npc_settimerevent_tick_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd, int *newtimer);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_settimerevent_tick_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_settimerevent_tick_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd, &newtimer);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_event(struct map_session_data *sd, const char *eventname, int ontouch) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_event_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *eventname, int *ontouch);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_event_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, eventname, &ontouch);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.event(sd, eventname, ontouch);
+	}
+	if( HPMHooks.count.HP_npc_event_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *eventname, int *ontouch);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, eventname, &ontouch);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_touch_areanpc_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_touch_areanpc_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_npc_touch_areanpc_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.npc.touch_areanpc_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_npc_touch_areanpc_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_npc_touch_areanpc_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_touchnext_areanpc(struct map_session_data *sd, bool leavemap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_touchnext_areanpc_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, bool *leavemap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touchnext_areanpc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_touchnext_areanpc_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &leavemap);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.touchnext_areanpc(sd, leavemap);
+	}
+	if( HPMHooks.count.HP_npc_touchnext_areanpc_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool *leavemap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touchnext_areanpc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_touchnext_areanpc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &leavemap);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_touch_areanpc(struct map_session_data *sd, int16 m, int16 x, int16 y) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_touch_areanpc_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x, int16 *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_touch_areanpc_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &m, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.touch_areanpc(sd, m, x, y);
+	}
+	if( HPMHooks.count.HP_npc_touch_areanpc_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 *m, int16 *x, int16 *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_touch_areanpc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &m, &x, &y);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_touch_areanpc2(struct mob_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_touch_areanpc2_pre ) {
+		int (*preHookFunc) (struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_touch_areanpc2_pre[hIndex].func;
+			retVal___ = preHookFunc(md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.touch_areanpc2(md);
+	}
+	if( HPMHooks.count.HP_npc_touch_areanpc2_post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_touch_areanpc2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_check_areanpc(int flag, int16 m, int16 x, int16 y, int16 range) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_check_areanpc_pre ) {
+		int (*preHookFunc) (int *flag, int16 *m, int16 *x, int16 *y, int16 *range);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_check_areanpc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_check_areanpc_pre[hIndex].func;
+			retVal___ = preHookFunc(&flag, &m, &x, &y, &range);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.check_areanpc(flag, m, x, y, range);
+	}
+	if( HPMHooks.count.HP_npc_check_areanpc_post ) {
+		int (*postHookFunc) (int retVal___, int *flag, int16 *m, int16 *x, int16 *y, int16 *range);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_check_areanpc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_check_areanpc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &flag, &m, &x, &y, &range);
+		}
+	}
+	return retVal___;
+}
+struct npc_data* HP_npc_checknear(struct map_session_data *sd, struct block_list *bl) {
+	int hIndex = 0;
+	struct npc_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_checknear_pre ) {
+		struct npc_data* (*preHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_checknear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_checknear_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.checknear(sd, bl);
+	}
+	if( HPMHooks.count.HP_npc_checknear_post ) {
+		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_checknear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_checknear_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_globalmessage(const char *name, const char *mes) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_globalmessage_pre ) {
+		int (*preHookFunc) (const char *name, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_globalmessage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_globalmessage_pre[hIndex].func;
+			retVal___ = preHookFunc(name, mes);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.globalmessage(name, mes);
+	}
+	if( HPMHooks.count.HP_npc_globalmessage_post ) {
+		int (*postHookFunc) (int retVal___, const char *name, const char *mes);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_globalmessage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_globalmessage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, mes);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_run_tomb(struct map_session_data *sd, struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_run_tomb_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_run_tomb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_run_tomb_pre[hIndex].func;
+			preHookFunc(sd, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.run_tomb(sd, nd);
+	}
+	if( HPMHooks.count.HP_npc_run_tomb_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_run_tomb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_run_tomb_post[hIndex].func;
+			postHookFunc(sd, nd);
+		}
+	}
+	return;
+}
+int HP_npc_click(struct map_session_data *sd, struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_click_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_click_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_click_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.click(sd, nd);
+	}
+	if( HPMHooks.count.HP_npc_click_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_click_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_click_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_scriptcont(struct map_session_data *sd, int id, bool closing) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_scriptcont_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *id, bool *closing);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_scriptcont_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_scriptcont_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &id, &closing);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.scriptcont(sd, id, closing);
+	}
+	if( HPMHooks.count.HP_npc_scriptcont_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *id, bool *closing);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_scriptcont_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_scriptcont_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &id, &closing);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_buysellsel(struct map_session_data *sd, int id, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_buysellsel_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *id, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buysellsel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_buysellsel_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &id, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.buysellsel(sd, id, type);
+	}
+	if( HPMHooks.count.HP_npc_buysellsel_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *id, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buysellsel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_buysellsel_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &id, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_cashshop_buylist(struct map_session_data *sd, int points, int count, unsigned short *item_list) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_cashshop_buylist_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *points, int *count, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buylist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_cashshop_buylist_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &points, &count, item_list);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.cashshop_buylist(sd, points, count, item_list);
+	}
+	if( HPMHooks.count.HP_npc_cashshop_buylist_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *points, int *count, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buylist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_cashshop_buylist_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &points, &count, item_list);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_buylist_sub(struct map_session_data *sd, int n, unsigned short *item_list, struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_buylist_sub_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, unsigned short *item_list, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buylist_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_buylist_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, item_list, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.buylist_sub(sd, n, item_list, nd);
+	}
+	if( HPMHooks.count.HP_npc_buylist_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, unsigned short *item_list, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buylist_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_buylist_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, item_list, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_cashshop_buy(struct map_session_data *sd, int nameid, int amount, int points) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_cashshop_buy_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *amount, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_cashshop_buy_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid, &amount, &points);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.cashshop_buy(sd, nameid, amount, points);
+	}
+	if( HPMHooks.count.HP_npc_cashshop_buy_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid, int *amount, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_cashshop_buy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid, &amount, &points);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_buylist(struct map_session_data *sd, int n, unsigned short *item_list) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_buylist_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buylist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_buylist_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, item_list);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.buylist(sd, n, item_list);
+	}
+	if( HPMHooks.count.HP_npc_buylist_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buylist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_buylist_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, item_list);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_selllist_sub(struct map_session_data *sd, int n, unsigned short *item_list, struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_selllist_sub_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, unsigned short *item_list, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_selllist_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_selllist_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, item_list, nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.selllist_sub(sd, n, item_list, nd);
+	}
+	if( HPMHooks.count.HP_npc_selllist_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, unsigned short *item_list, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_selllist_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_selllist_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, item_list, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_selllist(struct map_session_data *sd, int n, unsigned short *item_list) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_selllist_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_selllist_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_selllist_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, item_list);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.selllist(sd, n, item_list);
+	}
+	if( HPMHooks.count.HP_npc_selllist_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_selllist_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_selllist_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, item_list);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_remove_map(struct npc_data *nd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_remove_map_pre ) {
+		int (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_remove_map_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_remove_map_pre[hIndex].func;
+			retVal___ = preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.remove_map(nd);
+	}
+	if( HPMHooks.count.HP_npc_remove_map_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_remove_map_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_remove_map_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_unload_ev(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_unload_ev_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_npc_unload_ev_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.npc.unload_ev(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_npc_unload_ev_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_npc_unload_ev_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_unload_ev_label(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_unload_ev_label_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_label_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_npc_unload_ev_label_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.npc.unload_ev_label(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_npc_unload_ev_label_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_label_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_npc_unload_ev_label_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_unload_dup_sub(struct npc_data *nd, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_unload_dup_sub_pre ) {
+		int (*preHookFunc) (struct npc_data *nd, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_dup_sub_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_npc_unload_dup_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(nd, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.npc.unload_dup_sub(nd, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_npc_unload_dup_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_dup_sub_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_npc_unload_dup_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_unload_duplicates(struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_unload_duplicates_pre ) {
+		void (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_duplicates_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_unload_duplicates_pre[hIndex].func;
+			preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.unload_duplicates(nd);
+	}
+	if( HPMHooks.count.HP_npc_unload_duplicates_post ) {
+		void (*postHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_duplicates_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_unload_duplicates_post[hIndex].func;
+			postHookFunc(nd);
+		}
+	}
+	return;
+}
+int HP_npc_unload(struct npc_data *nd, bool single) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_unload_pre ) {
+		int (*preHookFunc) (struct npc_data *nd, bool *single);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_unload_pre[hIndex].func;
+			retVal___ = preHookFunc(nd, &single);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.unload(nd, single);
+	}
+	if( HPMHooks.count.HP_npc_unload_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd, bool *single);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_unload_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd, &single);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_clearsrcfile(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_clearsrcfile_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_clearsrcfile_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_clearsrcfile_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.clearsrcfile();
+	}
+	if( HPMHooks.count.HP_npc_clearsrcfile_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_clearsrcfile_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_clearsrcfile_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_npc_addsrcfile(const char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_addsrcfile_pre ) {
+		void (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_addsrcfile_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_addsrcfile_pre[hIndex].func;
+			preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.addsrcfile(name);
+	}
+	if( HPMHooks.count.HP_npc_addsrcfile_post ) {
+		void (*postHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_addsrcfile_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_addsrcfile_post[hIndex].func;
+			postHookFunc(name);
+		}
+	}
+	return;
+}
+void HP_npc_delsrcfile(const char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_delsrcfile_pre ) {
+		void (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_delsrcfile_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_delsrcfile_pre[hIndex].func;
+			preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.delsrcfile(name);
+	}
+	if( HPMHooks.count.HP_npc_delsrcfile_post ) {
+		void (*postHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_delsrcfile_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_delsrcfile_post[hIndex].func;
+			postHookFunc(name);
+		}
+	}
+	return;
+}
+void HP_npc_parsename(struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_parsename_pre ) {
+		void (*preHookFunc) (struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsename_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parsename_pre[hIndex].func;
+			preHookFunc(nd, name, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.parsename(nd, name, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_npc_parsename_post ) {
+		void (*postHookFunc) (struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsename_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parsename_post[hIndex].func;
+			postHookFunc(nd, name, start, buffer, filepath);
+		}
+	}
+	return;
+}
+struct npc_data* HP_npc_add_warp(char *name, short from_mapid, short from_x, short from_y, short xs, short ys, unsigned short to_mapindex, short to_x, short to_y) {
+	int hIndex = 0;
+	struct npc_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_add_warp_pre ) {
+		struct npc_data* (*preHookFunc) (char *name, short *from_mapid, short *from_x, short *from_y, short *xs, short *ys, unsigned short *to_mapindex, short *to_x, short *to_y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_add_warp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_add_warp_pre[hIndex].func;
+			retVal___ = preHookFunc(name, &from_mapid, &from_x, &from_y, &xs, &ys, &to_mapindex, &to_x, &to_y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.add_warp(name, from_mapid, from_x, from_y, xs, ys, to_mapindex, to_x, to_y);
+	}
+	if( HPMHooks.count.HP_npc_add_warp_post ) {
+		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, char *name, short *from_mapid, short *from_x, short *from_y, short *xs, short *ys, unsigned short *to_mapindex, short *to_x, short *to_y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_add_warp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_add_warp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, &from_mapid, &from_x, &from_y, &xs, &ys, &to_mapindex, &to_x, &to_y);
+		}
+	}
+	return retVal___;
+}
+const char* HP_npc_parse_warp(char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_parse_warp_pre ) {
+		const char* (*preHookFunc) (char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_warp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parse_warp_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.parse_warp(w1, w2, w3, w4, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_npc_parse_warp_post ) {
+		const char* (*postHookFunc) (const char* retVal___, char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_warp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parse_warp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath);
+		}
+	}
+	return retVal___;
+}
+const char* HP_npc_parse_shop(char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_parse_shop_pre ) {
+		const char* (*preHookFunc) (char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_shop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parse_shop_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.parse_shop(w1, w2, w3, w4, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_npc_parse_shop_post ) {
+		const char* (*postHookFunc) (const char* retVal___, char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_shop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parse_shop_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_convertlabel_db(struct npc_label_list *label_list, const char *filepath) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_convertlabel_db_pre ) {
+		void (*preHookFunc) (struct npc_label_list *label_list, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_convertlabel_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_convertlabel_db_pre[hIndex].func;
+			preHookFunc(label_list, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.convertlabel_db(label_list, filepath);
+	}
+	if( HPMHooks.count.HP_npc_convertlabel_db_post ) {
+		void (*postHookFunc) (struct npc_label_list *label_list, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_convertlabel_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_convertlabel_db_post[hIndex].func;
+			postHookFunc(label_list, filepath);
+		}
+	}
+	return;
+}
+const char* HP_npc_skip_script(const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_skip_script_pre ) {
+		const char* (*preHookFunc) (const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_skip_script_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_skip_script_pre[hIndex].func;
+			retVal___ = preHookFunc(start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.skip_script(start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_npc_skip_script_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_skip_script_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_skip_script_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, start, buffer, filepath);
+		}
+	}
+	return retVal___;
+}
+const char* HP_npc_parse_script(char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath, bool runOnInit) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_parse_script_pre ) {
+		const char* (*preHookFunc) (char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath, bool *runOnInit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_script_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parse_script_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath, &runOnInit);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.parse_script(w1, w2, w3, w4, start, buffer, filepath, runOnInit);
+	}
+	if( HPMHooks.count.HP_npc_parse_script_post ) {
+		const char* (*postHookFunc) (const char* retVal___, char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath, bool *runOnInit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_script_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parse_script_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, &runOnInit);
+		}
+	}
+	return retVal___;
+}
+const char* HP_npc_parse_duplicate(char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_parse_duplicate_pre ) {
+		const char* (*preHookFunc) (char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_duplicate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parse_duplicate_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.parse_duplicate(w1, w2, w3, w4, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_npc_parse_duplicate_post ) {
+		const char* (*postHookFunc) (const char* retVal___, char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_duplicate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parse_duplicate_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_duplicate4instance(struct npc_data *snd, int16 m) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_duplicate4instance_pre ) {
+		int (*preHookFunc) (struct npc_data *snd, int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate4instance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_duplicate4instance_pre[hIndex].func;
+			retVal___ = preHookFunc(snd, &m);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.duplicate4instance(snd, m);
+	}
+	if( HPMHooks.count.HP_npc_duplicate4instance_post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *snd, int16 *m);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate4instance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_duplicate4instance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, snd, &m);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_setcells(struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_setcells_pre ) {
+		void (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setcells_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_setcells_pre[hIndex].func;
+			preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.setcells(nd);
+	}
+	if( HPMHooks.count.HP_npc_setcells_post ) {
+		void (*postHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setcells_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_setcells_post[hIndex].func;
+			postHookFunc(nd);
+		}
+	}
+	return;
+}
+int HP_npc_unsetcells_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_unsetcells_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_npc_unsetcells_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.npc.unsetcells_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_npc_unsetcells_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_npc_unsetcells_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_unsetcells(struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_unsetcells_pre ) {
+		void (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_unsetcells_pre[hIndex].func;
+			preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.unsetcells(nd);
+	}
+	if( HPMHooks.count.HP_npc_unsetcells_post ) {
+		void (*postHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_unsetcells_post[hIndex].func;
+			postHookFunc(nd);
+		}
+	}
+	return;
+}
+void HP_npc_movenpc(struct npc_data *nd, int16 x, int16 y) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_movenpc_pre ) {
+		void (*preHookFunc) (struct npc_data *nd, int16 *x, int16 *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_movenpc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_movenpc_pre[hIndex].func;
+			preHookFunc(nd, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.movenpc(nd, x, y);
+	}
+	if( HPMHooks.count.HP_npc_movenpc_post ) {
+		void (*postHookFunc) (struct npc_data *nd, int16 *x, int16 *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_movenpc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_movenpc_post[hIndex].func;
+			postHookFunc(nd, &x, &y);
+		}
+	}
+	return;
+}
+void HP_npc_setdisplayname(struct npc_data *nd, const char *newname) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_setdisplayname_pre ) {
+		void (*preHookFunc) (struct npc_data *nd, const char *newname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setdisplayname_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_setdisplayname_pre[hIndex].func;
+			preHookFunc(nd, newname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.setdisplayname(nd, newname);
+	}
+	if( HPMHooks.count.HP_npc_setdisplayname_post ) {
+		void (*postHookFunc) (struct npc_data *nd, const char *newname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setdisplayname_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_setdisplayname_post[hIndex].func;
+			postHookFunc(nd, newname);
+		}
+	}
+	return;
+}
+void HP_npc_setclass(struct npc_data *nd, short class_) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_setclass_pre ) {
+		void (*preHookFunc) (struct npc_data *nd, short *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setclass_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_setclass_pre[hIndex].func;
+			preHookFunc(nd, &class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.setclass(nd, class_);
+	}
+	if( HPMHooks.count.HP_npc_setclass_post ) {
+		void (*postHookFunc) (struct npc_data *nd, short *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setclass_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_setclass_post[hIndex].func;
+			postHookFunc(nd, &class_);
+		}
+	}
+	return;
+}
+int HP_npc_do_atcmd_event(struct map_session_data *sd, const char *command, const char *message, const char *eventname) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_do_atcmd_event_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *command, const char *message, const char *eventname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_do_atcmd_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_do_atcmd_event_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, command, message, eventname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.do_atcmd_event(sd, command, message, eventname);
+	}
+	if( HPMHooks.count.HP_npc_do_atcmd_event_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *command, const char *message, const char *eventname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_do_atcmd_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_do_atcmd_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, command, message, eventname);
+		}
+	}
+	return retVal___;
+}
+const char* HP_npc_parse_function(char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_parse_function_pre ) {
+		const char* (*preHookFunc) (char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_function_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parse_function_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.parse_function(w1, w2, w3, w4, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_npc_parse_function_post ) {
+		const char* (*postHookFunc) (const char* retVal___, char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_function_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parse_function_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_parse_mob2(struct spawn_data *mobspawn) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_parse_mob2_pre ) {
+		void (*preHookFunc) (struct spawn_data *mobspawn);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parse_mob2_pre[hIndex].func;
+			preHookFunc(mobspawn);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.parse_mob2(mobspawn);
+	}
+	if( HPMHooks.count.HP_npc_parse_mob2_post ) {
+		void (*postHookFunc) (struct spawn_data *mobspawn);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parse_mob2_post[hIndex].func;
+			postHookFunc(mobspawn);
+		}
+	}
+	return;
+}
+const char* HP_npc_parse_mob(char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_parse_mob_pre ) {
+		const char* (*preHookFunc) (char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parse_mob_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.parse_mob(w1, w2, w3, w4, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_npc_parse_mob_post ) {
+		const char* (*postHookFunc) (const char* retVal___, char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parse_mob_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath);
+		}
+	}
+	return retVal___;
+}
+const char* HP_npc_parse_mapflag(char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_npc_parse_mapflag_pre ) {
+		const char* (*preHookFunc) (char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mapflag_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parse_mapflag_pre[hIndex].func;
+			retVal___ = preHookFunc(w1, w2, w3, w4, start, buffer, filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.parse_mapflag(w1, w2, w3, w4, start, buffer, filepath);
+	}
+	if( HPMHooks.count.HP_npc_parse_mapflag_post ) {
+		const char* (*postHookFunc) (const char* retVal___, char *w1, char *w2, char *w3, char *w4, const char *start, const char *buffer, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mapflag_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parse_mapflag_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_parsesrcfile(const char *filepath, bool runOnInit) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_parsesrcfile_pre ) {
+		void (*preHookFunc) (const char *filepath, bool *runOnInit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsesrcfile_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_parsesrcfile_pre[hIndex].func;
+			preHookFunc(filepath, &runOnInit);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.parsesrcfile(filepath, runOnInit);
+	}
+	if( HPMHooks.count.HP_npc_parsesrcfile_post ) {
+		void (*postHookFunc) (const char *filepath, bool *runOnInit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsesrcfile_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_parsesrcfile_post[hIndex].func;
+			postHookFunc(filepath, &runOnInit);
+		}
+	}
+	return;
+}
+int HP_npc_script_event(struct map_session_data *sd, enum npce_event type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_script_event_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, enum npce_event *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_script_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_script_event_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.script_event(sd, type);
+	}
+	if( HPMHooks.count.HP_npc_script_event_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum npce_event *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_script_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_script_event_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_read_event_script(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_read_event_script_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_read_event_script_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_read_event_script_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.read_event_script();
+	}
+	if( HPMHooks.count.HP_npc_read_event_script_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_read_event_script_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_read_event_script_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_npc_path_db_clear_sub(DBKey key, DBData *data, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_path_db_clear_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_path_db_clear_sub_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_npc_path_db_clear_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.npc.path_db_clear_sub(key, data, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_npc_path_db_clear_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_path_db_clear_sub_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_npc_path_db_clear_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_ev_label_db_clear_sub(DBKey key, DBData *data, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_ev_label_db_clear_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ev_label_db_clear_sub_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_npc_ev_label_db_clear_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.npc.ev_label_db_clear_sub(key, data, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_npc_ev_label_db_clear_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ev_label_db_clear_sub_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_npc_ev_label_db_clear_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_npc_reload(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_npc_reload_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_reload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_reload_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.reload();
+	}
+	if( HPMHooks.count.HP_npc_reload_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_reload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_reload_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+bool HP_npc_unloadfile(const char *filepath) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_npc_unloadfile_pre ) {
+		bool (*preHookFunc) (const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unloadfile_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_unloadfile_pre[hIndex].func;
+			retVal___ = preHookFunc(filepath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.npc.unloadfile(filepath);
+	}
+	if( HPMHooks.count.HP_npc_unloadfile_post ) {
+		bool (*postHookFunc) (bool retVal___, const char *filepath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unloadfile_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_unloadfile_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, filepath);
+		}
+	}
+	return retVal___;
+}
+void HP_npc_do_clear_npc(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_do_clear_npc_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_do_clear_npc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_do_clear_npc_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.do_clear_npc();
+	}
+	if( HPMHooks.count.HP_npc_do_clear_npc_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_do_clear_npc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_do_clear_npc_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_npc_debug_warps_sub(struct npc_data *nd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_debug_warps_sub_pre ) {
+		void (*preHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_debug_warps_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_debug_warps_sub_pre[hIndex].func;
+			preHookFunc(nd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.debug_warps_sub(nd);
+	}
+	if( HPMHooks.count.HP_npc_debug_warps_sub_post ) {
+		void (*postHookFunc) (struct npc_data *nd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_debug_warps_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_debug_warps_sub_post[hIndex].func;
+			postHookFunc(nd);
+		}
+	}
+	return;
+}
+void HP_npc_debug_warps(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_npc_debug_warps_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_debug_warps_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_npc_debug_warps_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.npc.debug_warps();
+	}
+	if( HPMHooks.count.HP_npc_debug_warps_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_debug_warps_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_npc_debug_warps_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+/* party */
+void HP_party_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.init();
+	}
+	if( HPMHooks.count.HP_party_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_party_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.final();
+	}
+	if( HPMHooks.count.HP_party_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct party_data* HP_party_search(int party_id) {
+	int hIndex = 0;
+	struct party_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_party_search_pre ) {
+		struct party_data* (*preHookFunc) (int *party_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_search_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.search(party_id);
+	}
+	if( HPMHooks.count.HP_party_search_post ) {
+		struct party_data* (*postHookFunc) (struct party_data* retVal___, int *party_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id);
+		}
+	}
+	return retVal___;
+}
+struct party_data* HP_party_searchname(const char *str) {
+	int hIndex = 0;
+	struct party_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_party_searchname_pre ) {
+		struct party_data* (*preHookFunc) (const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_searchname_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_searchname_pre[hIndex].func;
+			retVal___ = preHookFunc(str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.searchname(str);
+	}
+	if( HPMHooks.count.HP_party_searchname_post ) {
+		struct party_data* (*postHookFunc) (struct party_data* retVal___, const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_searchname_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_searchname_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str);
+		}
+	}
+	return retVal___;
+}
+int HP_party_getmemberid(struct party_data *p, struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_getmemberid_pre ) {
+		int (*preHookFunc) (struct party_data *p, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getmemberid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_getmemberid_pre[hIndex].func;
+			retVal___ = preHookFunc(p, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.getmemberid(p, sd);
+	}
+	if( HPMHooks.count.HP_party_getmemberid_post ) {
+		int (*postHookFunc) (int retVal___, struct party_data *p, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getmemberid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_getmemberid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p, sd);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_party_getavailablesd(struct party_data *p) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_party_getavailablesd_pre ) {
+		struct map_session_data* (*preHookFunc) (struct party_data *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getavailablesd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_getavailablesd_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.getavailablesd(p);
+	}
+	if( HPMHooks.count.HP_party_getavailablesd_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct party_data *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getavailablesd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_getavailablesd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+int HP_party_create(struct map_session_data *sd, char *name, int item, int item2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_create_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, char *name, int *item, int *item2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_create_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name, &item, &item2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.create(sd, name, item, item2);
+	}
+	if( HPMHooks.count.HP_party_create_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, char *name, int *item, int *item2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name, &item, &item2);
+		}
+	}
+	return retVal___;
+}
+void HP_party_created(int account_id, int char_id, int fail, int party_id, char *name) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_created_pre ) {
+		void (*preHookFunc) (int *account_id, int *char_id, int *fail, int *party_id, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_created_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_created_pre[hIndex].func;
+			preHookFunc(&account_id, &char_id, &fail, &party_id, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.created(account_id, char_id, fail, party_id, name);
+	}
+	if( HPMHooks.count.HP_party_created_post ) {
+		void (*postHookFunc) (int *account_id, int *char_id, int *fail, int *party_id, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_created_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_created_post[hIndex].func;
+			postHookFunc(&account_id, &char_id, &fail, &party_id, name);
+		}
+	}
+	return;
+}
+int HP_party_request_info(int party_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_request_info_pre ) {
+		int (*preHookFunc) (int *party_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_request_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_request_info_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.request_info(party_id, char_id);
+	}
+	if( HPMHooks.count.HP_party_request_info_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_request_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_request_info_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_party_invite(struct map_session_data *sd, struct map_session_data *tsd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_invite_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_invite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_invite_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.invite(sd, tsd);
+	}
+	if( HPMHooks.count.HP_party_invite_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_invite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_invite_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, tsd);
+		}
+	}
+	return retVal___;
+}
+void HP_party_member_joined(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_member_joined_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_joined_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_member_joined_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.member_joined(sd);
+	}
+	if( HPMHooks.count.HP_party_member_joined_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_joined_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_member_joined_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_party_member_added(int party_id, int account_id, int char_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_member_added_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, int *char_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_added_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_member_added_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, &char_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.member_added(party_id, account_id, char_id, flag);
+	}
+	if( HPMHooks.count.HP_party_member_added_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_added_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_member_added_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_party_leave(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_leave_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_leave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_leave_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.leave(sd);
+	}
+	if( HPMHooks.count.HP_party_leave_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_leave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_leave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_party_removemember(struct map_session_data *sd, int account_id, char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_removemember_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *account_id, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_removemember_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_removemember_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &account_id, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.removemember(sd, account_id, name);
+	}
+	if( HPMHooks.count.HP_party_removemember_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *account_id, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_removemember_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_removemember_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &account_id, name);
+		}
+	}
+	return retVal___;
+}
+int HP_party_member_withdraw(int party_id, int account_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_member_withdraw_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_withdraw_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_member_withdraw_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.member_withdraw(party_id, account_id, char_id);
+	}
+	if( HPMHooks.count.HP_party_member_withdraw_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_withdraw_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_member_withdraw_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+void HP_party_reply_invite(struct map_session_data *sd, int party_id, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_reply_invite_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *party_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_reply_invite_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_reply_invite_pre[hIndex].func;
+			preHookFunc(sd, &party_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.reply_invite(sd, party_id, flag);
+	}
+	if( HPMHooks.count.HP_party_reply_invite_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *party_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_reply_invite_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_reply_invite_post[hIndex].func;
+			postHookFunc(sd, &party_id, &flag);
+		}
+	}
+	return;
+}
+int HP_party_recv_noinfo(int party_id, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_recv_noinfo_pre ) {
+		int (*preHookFunc) (int *party_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_noinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_recv_noinfo_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.recv_noinfo(party_id, char_id);
+	}
+	if( HPMHooks.count.HP_party_recv_noinfo_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_noinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_recv_noinfo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_party_recv_info(struct party *sp, int char_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_recv_info_pre ) {
+		int (*preHookFunc) (struct party *sp, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_info_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_recv_info_pre[hIndex].func;
+			retVal___ = preHookFunc(sp, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.recv_info(sp, char_id);
+	}
+	if( HPMHooks.count.HP_party_recv_info_post ) {
+		int (*postHookFunc) (int retVal___, struct party *sp, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_info_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_recv_info_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sp, &char_id);
+		}
+	}
+	return retVal___;
+}
+int HP_party_recv_movemap(int party_id, int account_id, int char_id, unsigned short mapid, int online, int lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_recv_movemap_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, int *char_id, unsigned short *mapid, int *online, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_movemap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_recv_movemap_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, &char_id, &mapid, &online, &lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.recv_movemap(party_id, account_id, char_id, mapid, online, lv);
+	}
+	if( HPMHooks.count.HP_party_recv_movemap_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *char_id, unsigned short *mapid, int *online, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_movemap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_recv_movemap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id, &mapid, &online, &lv);
+		}
+	}
+	return retVal___;
+}
+int HP_party_broken(int party_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_broken_pre ) {
+		int (*preHookFunc) (int *party_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_broken_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_broken_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.broken(party_id);
+	}
+	if( HPMHooks.count.HP_party_broken_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_broken_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_broken_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id);
+		}
+	}
+	return retVal___;
+}
+int HP_party_optionchanged(int party_id, int account_id, int exp, int item, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_optionchanged_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, int *exp, int *item, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_optionchanged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_optionchanged_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, &exp, &item, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.optionchanged(party_id, account_id, exp, item, flag);
+	}
+	if( HPMHooks.count.HP_party_optionchanged_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, int *exp, int *item, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_optionchanged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_optionchanged_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, &exp, &item, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_party_changeoption(struct map_session_data *sd, int exp, int item) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_changeoption_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *exp, int *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeoption_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_changeoption_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &exp, &item);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.changeoption(sd, exp, item);
+	}
+	if( HPMHooks.count.HP_party_changeoption_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *exp, int *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeoption_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_changeoption_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &exp, &item);
+		}
+	}
+	return retVal___;
+}
+bool HP_party_changeleader(struct map_session_data *sd, struct map_session_data *t_sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_party_changeleader_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, struct map_session_data *t_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeleader_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_changeleader_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, t_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.changeleader(sd, t_sd);
+	}
+	if( HPMHooks.count.HP_party_changeleader_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct map_session_data *t_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeleader_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_changeleader_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, t_sd);
+		}
+	}
+	return retVal___;
+}
+void HP_party_send_movemap(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_send_movemap_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_movemap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_send_movemap_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.send_movemap(sd);
+	}
+	if( HPMHooks.count.HP_party_send_movemap_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_movemap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_send_movemap_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_party_send_levelup(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_send_levelup_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_levelup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_send_levelup_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.send_levelup(sd);
+	}
+	if( HPMHooks.count.HP_party_send_levelup_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_levelup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_send_levelup_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_party_send_logout(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_send_logout_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_logout_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_send_logout_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.send_logout(sd);
+	}
+	if( HPMHooks.count.HP_party_send_logout_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_logout_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_send_logout_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_party_send_message(struct map_session_data *sd, const char *mes, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_send_message_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_send_message_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.send_message(sd, mes, len);
+	}
+	if( HPMHooks.count.HP_party_send_message_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_send_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, mes, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_party_recv_message(int party_id, int account_id, const char *mes, int len) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_recv_message_pre ) {
+		int (*preHookFunc) (int *party_id, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_recv_message_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, mes, &len);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.recv_message(party_id, account_id, mes, len);
+	}
+	if( HPMHooks.count.HP_party_recv_message_post ) {
+		int (*postHookFunc) (int retVal___, int *party_id, int *account_id, const char *mes, int *len);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_recv_message_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, mes, &len);
+		}
+	}
+	return retVal___;
+}
+int HP_party_skill_check(struct map_session_data *sd, int party_id, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_skill_check_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *party_id, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_skill_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_skill_check_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &party_id, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.skill_check(sd, party_id, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_party_skill_check_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *party_id, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_skill_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_skill_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &party_id, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_party_send_xy_clear(struct party_data *p) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_send_xy_clear_pre ) {
+		int (*preHookFunc) (struct party_data *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_xy_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_send_xy_clear_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.send_xy_clear(p);
+	}
+	if( HPMHooks.count.HP_party_send_xy_clear_post ) {
+		int (*postHookFunc) (int retVal___, struct party_data *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_xy_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_send_xy_clear_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+int HP_party_exp_share(struct party_data *p, struct block_list *src, unsigned int base_exp, unsigned int job_exp, int zeny) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_exp_share_pre ) {
+		int (*preHookFunc) (struct party_data *p, struct block_list *src, unsigned int *base_exp, unsigned int *job_exp, int *zeny);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_exp_share_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_exp_share_pre[hIndex].func;
+			retVal___ = preHookFunc(p, src, &base_exp, &job_exp, &zeny);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.exp_share(p, src, base_exp, job_exp, zeny);
+	}
+	if( HPMHooks.count.HP_party_exp_share_post ) {
+		int (*postHookFunc) (int retVal___, struct party_data *p, struct block_list *src, unsigned int *base_exp, unsigned int *job_exp, int *zeny);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_exp_share_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_exp_share_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p, src, &base_exp, &job_exp, &zeny);
+		}
+	}
+	return retVal___;
+}
+int HP_party_share_loot(struct party_data *p, struct map_session_data *sd, struct item *item_data, int first_charid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_share_loot_pre ) {
+		int (*preHookFunc) (struct party_data *p, struct map_session_data *sd, struct item *item_data, int *first_charid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_share_loot_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_share_loot_pre[hIndex].func;
+			retVal___ = preHookFunc(p, sd, item_data, &first_charid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.share_loot(p, sd, item_data, first_charid);
+	}
+	if( HPMHooks.count.HP_party_share_loot_post ) {
+		int (*postHookFunc) (int retVal___, struct party_data *p, struct map_session_data *sd, struct item *item_data, int *first_charid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_share_loot_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_share_loot_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p, sd, item_data, &first_charid);
+		}
+	}
+	return retVal___;
+}
+int HP_party_send_dot_remove(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_send_dot_remove_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_dot_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_send_dot_remove_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.send_dot_remove(sd);
+	}
+	if( HPMHooks.count.HP_party_send_dot_remove_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_dot_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_send_dot_remove_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_party_sub_count(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_sub_count_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sub_count_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_party_sub_count_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.party.sub_count(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_party_sub_count_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sub_count_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_party_sub_count_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_party_booking_register(struct map_session_data *sd, short level, const char *notice) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_booking_register_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *level, const char *notice);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_register_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_booking_register_pre[hIndex].func;
+			preHookFunc(sd, &level, notice);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.booking_register(sd, level, notice);
+	}
+	if( HPMHooks.count.HP_party_booking_register_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *level, const char *notice);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_register_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_booking_register_post[hIndex].func;
+			postHookFunc(sd, &level, notice);
+		}
+	}
+	return;
+}
+void HP_party_booking_update(struct map_session_data *sd, const char *notice) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_booking_update_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *notice);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_update_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_booking_update_pre[hIndex].func;
+			preHookFunc(sd, notice);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.booking_update(sd, notice);
+	}
+	if( HPMHooks.count.HP_party_booking_update_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *notice);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_update_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_booking_update_post[hIndex].func;
+			postHookFunc(sd, notice);
+		}
+	}
+	return;
+}
+void HP_party_booking_search(struct map_session_data *sd, short level, short mapid, unsigned long lastindex, short resultcount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_booking_search_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *level, short *mapid, unsigned long *lastindex, short *resultcount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_booking_search_pre[hIndex].func;
+			preHookFunc(sd, &level, &mapid, &lastindex, &resultcount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.booking_search(sd, level, mapid, lastindex, resultcount);
+	}
+	if( HPMHooks.count.HP_party_booking_search_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *level, short *mapid, unsigned long *lastindex, short *resultcount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_booking_search_post[hIndex].func;
+			postHookFunc(sd, &level, &mapid, &lastindex, &resultcount);
+		}
+	}
+	return;
+}
+bool HP_party_booking_delete(struct map_session_data *sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_party_booking_delete_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_booking_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.booking_delete(sd);
+	}
+	if( HPMHooks.count.HP_party_booking_delete_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_booking_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_party_vforeachsamemap(int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int range, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_vforeachsamemap_pre ) {
+		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int *range, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_vforeachsamemap_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_party_vforeachsamemap_pre[hIndex].func;
+			retVal___ = preHookFunc(func, sd, &range, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.party.vforeachsamemap(func, sd, range, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_party_vforeachsamemap_post ) {
+		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int *range, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_vforeachsamemap_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_party_vforeachsamemap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, func, sd, &range, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_party_send_xy_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_send_xy_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_xy_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_send_xy_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.send_xy_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_party_send_xy_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_xy_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_send_xy_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_party_fill_member(struct party_member *member, struct map_session_data *sd, unsigned int leader) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_fill_member_pre ) {
+		void (*preHookFunc) (struct party_member *member, struct map_session_data *sd, unsigned int *leader);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_fill_member_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_fill_member_pre[hIndex].func;
+			preHookFunc(member, sd, &leader);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.fill_member(member, sd, leader);
+	}
+	if( HPMHooks.count.HP_party_fill_member_post ) {
+		void (*postHookFunc) (struct party_member *member, struct map_session_data *sd, unsigned int *leader);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_fill_member_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_fill_member_post[hIndex].func;
+			postHookFunc(member, sd, &leader);
+		}
+	}
+	return;
+}
+TBL_PC* HP_party_sd_check(int party_id, int account_id, int char_id) {
+	int hIndex = 0;
+	TBL_PC* retVal___ = NULL;
+	if( HPMHooks.count.HP_party_sd_check_pre ) {
+		TBL_PC* (*preHookFunc) (int *party_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sd_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_sd_check_pre[hIndex].func;
+			retVal___ = preHookFunc(&party_id, &account_id, &char_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.sd_check(party_id, account_id, char_id);
+	}
+	if( HPMHooks.count.HP_party_sd_check_post ) {
+		TBL_PC* (*postHookFunc) (TBL_PC* retVal___, int *party_id, int *account_id, int *char_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sd_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_sd_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &party_id, &account_id, &char_id);
+		}
+	}
+	return retVal___;
+}
+void HP_party_check_state(struct party_data *p) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_party_check_state_pre ) {
+		void (*preHookFunc) (struct party_data *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_check_state_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_check_state_pre[hIndex].func;
+			preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.party.check_state(p);
+	}
+	if( HPMHooks.count.HP_party_check_state_post ) {
+		void (*postHookFunc) (struct party_data *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_check_state_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_check_state_post[hIndex].func;
+			postHookFunc(p);
+		}
+	}
+	return;
+}
+struct party_booking_ad_info* HP_party_create_booking_data(void) {
+	int hIndex = 0;
+	struct party_booking_ad_info* retVal___ = NULL;
+	if( HPMHooks.count.HP_party_create_booking_data_pre ) {
+		struct party_booking_ad_info* (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_create_booking_data_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_party_create_booking_data_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.party.create_booking_data();
+	}
+	if( HPMHooks.count.HP_party_create_booking_data_post ) {
+		struct party_booking_ad_info* (*postHookFunc) (struct party_booking_ad_info* retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_create_booking_data_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_party_create_booking_data_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_party_db_final(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_party_db_final_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_db_final_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_party_db_final_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.party.db_final(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_party_db_final_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_db_final_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_party_db_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+/* path */
+int HP_path_blownpos(int16 m, int16 x0, int16 y0, int16 dx, int16 dy, int count) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_path_blownpos_pre ) {
+		int (*preHookFunc) (int16 *m, int16 *x0, int16 *y0, int16 *dx, int16 *dy, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_blownpos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_path_blownpos_pre[hIndex].func;
+			retVal___ = preHookFunc(&m, &x0, &y0, &dx, &dy, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.path.blownpos(m, x0, y0, dx, dy, count);
+	}
+	if( HPMHooks.count.HP_path_blownpos_post ) {
+		int (*postHookFunc) (int retVal___, int16 *m, int16 *x0, int16 *y0, int16 *dx, int16 *dy, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_blownpos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_path_blownpos_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &m, &x0, &y0, &dx, &dy, &count);
+		}
+	}
+	return retVal___;
+}
+bool HP_path_search(struct walkpath_data *wpd, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int flag, cell_chk cell) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_path_search_pre ) {
+		bool (*preHookFunc) (struct walkpath_data *wpd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *flag, cell_chk *cell);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_path_search_pre[hIndex].func;
+			retVal___ = preHookFunc(wpd, &m, &x0, &y0, &x1, &y1, &flag, &cell);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.path.search(wpd, m, x0, y0, x1, y1, flag, cell);
+	}
+	if( HPMHooks.count.HP_path_search_post ) {
+		bool (*postHookFunc) (bool retVal___, struct walkpath_data *wpd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, int *flag, cell_chk *cell);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_path_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, wpd, &m, &x0, &y0, &x1, &y1, &flag, &cell);
+		}
+	}
+	return retVal___;
+}
+bool HP_path_search_long(struct shootpath_data *spd, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, cell_chk cell) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_path_search_long_pre ) {
+		bool (*preHookFunc) (struct shootpath_data *spd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, cell_chk *cell);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_long_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_path_search_long_pre[hIndex].func;
+			retVal___ = preHookFunc(spd, &m, &x0, &y0, &x1, &y1, &cell);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.path.search_long(spd, m, x0, y0, x1, y1, cell);
+	}
+	if( HPMHooks.count.HP_path_search_long_post ) {
+		bool (*postHookFunc) (bool retVal___, struct shootpath_data *spd, int16 *m, int16 *x0, int16 *y0, int16 *x1, int16 *y1, cell_chk *cell);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_long_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_path_search_long_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, spd, &m, &x0, &y0, &x1, &y1, &cell);
+		}
+	}
+	return retVal___;
+}
+int HP_path_check_distance(int dx, int dy, int distance) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_path_check_distance_pre ) {
+		int (*preHookFunc) (int *dx, int *dy, int *distance);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_check_distance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_path_check_distance_pre[hIndex].func;
+			retVal___ = preHookFunc(&dx, &dy, &distance);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.path.check_distance(dx, dy, distance);
+	}
+	if( HPMHooks.count.HP_path_check_distance_post ) {
+		int (*postHookFunc) (int retVal___, int *dx, int *dy, int *distance);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_check_distance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_path_check_distance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &dx, &dy, &distance);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_path_distance(int dx, int dy) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_path_distance_pre ) {
+		unsigned int (*preHookFunc) (int *dx, int *dy);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_distance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_path_distance_pre[hIndex].func;
+			retVal___ = preHookFunc(&dx, &dy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.path.distance(dx, dy);
+	}
+	if( HPMHooks.count.HP_path_distance_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, int *dx, int *dy);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_distance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_path_distance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &dx, &dy);
+		}
+	}
+	return retVal___;
+}
+/* pc */
+void HP_pc_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.init();
+	}
+	if( HPMHooks.count.HP_pc_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_pc_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.final();
+	}
+	if( HPMHooks.count.HP_pc_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+struct map_session_data* HP_pc_get_dummy_sd(void) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_pc_get_dummy_sd_pre ) {
+		struct map_session_data* (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_dummy_sd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_get_dummy_sd_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.get_dummy_sd();
+	}
+	if( HPMHooks.count.HP_pc_get_dummy_sd_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_dummy_sd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_get_dummy_sd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_class2idx(int class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_class2idx_pre ) {
+		int (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_class2idx_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_class2idx_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.class2idx(class_);
+	}
+	if( HPMHooks.count.HP_pc_class2idx_post ) {
+		int (*postHookFunc) (int retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_class2idx_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_class2idx_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_get_group_level(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_get_group_level_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_group_level_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_get_group_level_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.get_group_level(sd);
+	}
+	if( HPMHooks.count.HP_pc_get_group_level_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_group_level_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_get_group_level_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_can_give_items(struct map_session_data *sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_can_give_items_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_give_items_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_can_give_items_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.can_give_items(sd);
+	}
+	if( HPMHooks.count.HP_pc_can_give_items_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_give_items_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_can_give_items_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_can_use_command(struct map_session_data *sd, const char *command) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_can_use_command_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, const char *command);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_use_command_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_can_use_command_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, command);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.can_use_command(sd, command);
+	}
+	if( HPMHooks.count.HP_pc_can_use_command_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *command);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_use_command_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_can_use_command_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, command);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_has_permission(struct map_session_data *sd, enum e_pc_permission permission) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_has_permission_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, enum e_pc_permission *permission);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_has_permission_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_has_permission_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &permission);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.has_permission(sd, permission);
+	}
+	if( HPMHooks.count.HP_pc_has_permission_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, enum e_pc_permission *permission);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_has_permission_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_has_permission_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &permission);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_set_group(struct map_session_data *sd, int group_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_set_group_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *group_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_group_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_set_group_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &group_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.set_group(sd, group_id);
+	}
+	if( HPMHooks.count.HP_pc_set_group_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *group_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_group_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_set_group_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &group_id);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_should_log_commands(struct map_session_data *sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_should_log_commands_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_should_log_commands_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_should_log_commands_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.should_log_commands(sd);
+	}
+	if( HPMHooks.count.HP_pc_should_log_commands_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_should_log_commands_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_should_log_commands_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setrestartvalue(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setrestartvalue_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setrestartvalue_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setrestartvalue_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setrestartvalue(sd, type);
+	}
+	if( HPMHooks.count.HP_pc_setrestartvalue_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setrestartvalue_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setrestartvalue_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_makesavestatus(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_makesavestatus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_makesavestatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_makesavestatus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.makesavestatus(sd);
+	}
+	if( HPMHooks.count.HP_pc_makesavestatus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_makesavestatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_makesavestatus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_respawn(struct map_session_data *sd, clr_type clrtype) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_respawn_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, clr_type *clrtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_respawn_pre[hIndex].func;
+			preHookFunc(sd, &clrtype);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.respawn(sd, clrtype);
+	}
+	if( HPMHooks.count.HP_pc_respawn_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, clr_type *clrtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_respawn_post[hIndex].func;
+			postHookFunc(sd, &clrtype);
+		}
+	}
+	return;
+}
+int HP_pc_setnewpc(struct map_session_data *sd, int account_id, int char_id, int login_id1, unsigned int client_tick, int sex, int fd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setnewpc_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *account_id, int *char_id, int *login_id1, unsigned int *client_tick, int *sex, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setnewpc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setnewpc_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &account_id, &char_id, &login_id1, &client_tick, &sex, &fd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setnewpc(sd, account_id, char_id, login_id1, client_tick, sex, fd);
+	}
+	if( HPMHooks.count.HP_pc_setnewpc_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *account_id, int *char_id, int *login_id1, unsigned int *client_tick, int *sex, int *fd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setnewpc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setnewpc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &account_id, &char_id, &login_id1, &client_tick, &sex, &fd);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_time, int group_id, struct mmo_charstatus *st, bool changing_mapservers) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_authok_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, int *login_id2, time_t *expiration_time, int *group_id, struct mmo_charstatus *st, bool *changing_mapservers);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_authok_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &login_id2, &expiration_time, &group_id, st, &changing_mapservers);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.authok(sd, login_id2, expiration_time, group_id, st, changing_mapservers);
+	}
+	if( HPMHooks.count.HP_pc_authok_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *login_id2, time_t *expiration_time, int *group_id, struct mmo_charstatus *st, bool *changing_mapservers);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_authok_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &login_id2, &expiration_time, &group_id, st, &changing_mapservers);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_authfail(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_authfail_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authfail_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_authfail_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.authfail(sd);
+	}
+	if( HPMHooks.count.HP_pc_authfail_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authfail_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_authfail_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_pc_reg_received(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_reg_received_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_reg_received_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_reg_received_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.reg_received(sd);
+	}
+	if( HPMHooks.count.HP_pc_reg_received_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_reg_received_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_reg_received_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_isequip(struct map_session_data *sd, int n) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_isequip_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_isequip_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.isequip(sd, n);
+	}
+	if( HPMHooks.count.HP_pc_isequip_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_isequip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_equippoint(struct map_session_data *sd, int n) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_equippoint_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equippoint_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_equippoint_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.equippoint(sd, n);
+	}
+	if( HPMHooks.count.HP_pc_equippoint_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equippoint_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_equippoint_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setinventorydata(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setinventorydata_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinventorydata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setinventorydata_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setinventorydata(sd);
+	}
+	if( HPMHooks.count.HP_pc_setinventorydata_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinventorydata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setinventorydata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkskill(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkskill_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkskill_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkskill(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_pc_checkskill_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkskill2(struct map_session_data *sd, uint16 index) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkskill2_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkskill2_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkskill2(sd, index);
+	}
+	if( HPMHooks.count.HP_pc_checkskill2_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkskill2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkallowskill(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkallowskill_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkallowskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkallowskill_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkallowskill(sd);
+	}
+	if( HPMHooks.count.HP_pc_checkallowskill_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkallowskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkallowskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkequip(struct map_session_data *sd, int pos) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkequip_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkequip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkequip_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkequip(sd, pos);
+	}
+	if( HPMHooks.count.HP_pc_checkequip_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkequip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkequip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &pos);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_calc_skilltree(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_calc_skilltree_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_calc_skilltree_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.calc_skilltree(sd);
+	}
+	if( HPMHooks.count.HP_pc_calc_skilltree_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_calc_skilltree_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_calc_skilltree_normalize_job(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_calc_skilltree_normalize_job_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_normalize_job_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_calc_skilltree_normalize_job_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.calc_skilltree_normalize_job(sd);
+	}
+	if( HPMHooks.count.HP_pc_calc_skilltree_normalize_job_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_normalize_job_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_calc_skilltree_normalize_job_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_clean_skilltree(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_clean_skilltree_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_clean_skilltree_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_clean_skilltree_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.clean_skilltree(sd);
+	}
+	if( HPMHooks.count.HP_pc_clean_skilltree_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_clean_skilltree_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_clean_skilltree_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setpos(struct map_session_data *sd, unsigned short mapindex, int x, int y, clr_type clrtype) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setpos_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, unsigned short *mapindex, int *x, int *y, clr_type *clrtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setpos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setpos_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &mapindex, &x, &y, &clrtype);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setpos(sd, mapindex, x, y, clrtype);
+	}
+	if( HPMHooks.count.HP_pc_setpos_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, unsigned short *mapindex, int *x, int *y, clr_type *clrtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setpos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setpos_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &mapindex, &x, &y, &clrtype);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setsavepoint(struct map_session_data *sd, short mapindex, int x, int y) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setsavepoint_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, short *mapindex, int *x, int *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setsavepoint_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setsavepoint_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &mapindex, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setsavepoint(sd, mapindex, x, y);
+	}
+	if( HPMHooks.count.HP_pc_setsavepoint_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, short *mapindex, int *x, int *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setsavepoint_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setsavepoint_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &mapindex, &x, &y);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_randomwarp(struct map_session_data *sd, clr_type type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_randomwarp_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, clr_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_randomwarp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_randomwarp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.randomwarp(sd, type);
+	}
+	if( HPMHooks.count.HP_pc_randomwarp_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, clr_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_randomwarp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_randomwarp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_memo(struct map_session_data *sd, int pos) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_memo_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_memo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_memo_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.memo(sd, pos);
+	}
+	if( HPMHooks.count.HP_pc_memo_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_memo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_memo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &pos);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkadditem(struct map_session_data *sd, int nameid, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkadditem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkadditem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkadditem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkadditem(sd, nameid, amount);
+	}
+	if( HPMHooks.count.HP_pc_checkadditem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkadditem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkadditem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_inventoryblank(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_inventoryblank_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventoryblank_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_inventoryblank_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.inventoryblank(sd);
+	}
+	if( HPMHooks.count.HP_pc_inventoryblank_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventoryblank_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_inventoryblank_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_search_inventory(struct map_session_data *sd, int item_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_search_inventory_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *item_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_search_inventory_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_search_inventory_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &item_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.search_inventory(sd, item_id);
+	}
+	if( HPMHooks.count.HP_pc_search_inventory_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *item_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_search_inventory_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_search_inventory_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &item_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_payzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_payzeny_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *zeny, enum e_log_pick_type *type, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_payzeny_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_payzeny_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &zeny, &type, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.payzeny(sd, zeny, type, tsd);
+	}
+	if( HPMHooks.count.HP_pc_payzeny_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *zeny, enum e_log_pick_type *type, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_payzeny_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_payzeny_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &zeny, &type, tsd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_additem(struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_additem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct item *item_data, int *amount, e_log_pick_type *log_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_additem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_additem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, item_data, &amount, &log_type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.additem(sd, item_data, amount, log_type);
+	}
+	if( HPMHooks.count.HP_pc_additem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int *amount, e_log_pick_type *log_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_additem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_additem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, item_data, &amount, &log_type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_getzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_getzeny_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *zeny, enum e_log_pick_type *type, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getzeny_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_getzeny_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &zeny, &type, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.getzeny(sd, zeny, type, tsd);
+	}
+	if( HPMHooks.count.HP_pc_getzeny_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *zeny, enum e_log_pick_type *type, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getzeny_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_getzeny_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &zeny, &type, tsd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_delitem(struct map_session_data *sd, int n, int amount, int type, short reason, e_log_pick_type log_type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_delitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *type, short *reason, e_log_pick_type *log_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_delitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, &amount, &type, &reason, &log_type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.delitem(sd, n, amount, type, reason, log_type);
+	}
+	if( HPMHooks.count.HP_pc_delitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *amount, int *type, short *reason, e_log_pick_type *log_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_delitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, &amount, &type, &reason, &log_type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_paycash(struct map_session_data *sd, int price, int points) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_paycash_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *price, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_paycash_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_paycash_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &price, &points);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.paycash(sd, price, points);
+	}
+	if( HPMHooks.count.HP_pc_paycash_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *price, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_paycash_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_paycash_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &price, &points);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_getcash(struct map_session_data *sd, int cash, int points) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_getcash_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *cash, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getcash_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_getcash_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &cash, &points);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.getcash(sd, cash, points);
+	}
+	if( HPMHooks.count.HP_pc_getcash_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *cash, int *points);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getcash_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_getcash_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &cash, &points);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_cart_additem(struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_cart_additem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct item *item_data, int *amount, e_log_pick_type *log_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_additem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_cart_additem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, item_data, &amount, &log_type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.cart_additem(sd, item_data, amount, log_type);
+	}
+	if( HPMHooks.count.HP_pc_cart_additem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int *amount, e_log_pick_type *log_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_additem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_cart_additem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, item_data, &amount, &log_type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_cart_delitem(struct map_session_data *sd, int n, int amount, int type, e_log_pick_type log_type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_cart_delitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *type, e_log_pick_type *log_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_delitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_cart_delitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, &amount, &type, &log_type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.cart_delitem(sd, n, amount, type, log_type);
+	}
+	if( HPMHooks.count.HP_pc_cart_delitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *amount, int *type, e_log_pick_type *log_type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_delitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_cart_delitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, &amount, &type, &log_type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_putitemtocart(struct map_session_data *sd, int idx, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_putitemtocart_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_putitemtocart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_putitemtocart_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &idx, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.putitemtocart(sd, idx, amount);
+	}
+	if( HPMHooks.count.HP_pc_putitemtocart_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *idx, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_putitemtocart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_putitemtocart_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &idx, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_getitemfromcart(struct map_session_data *sd, int idx, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_getitemfromcart_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getitemfromcart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_getitemfromcart_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &idx, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.getitemfromcart(sd, idx, amount);
+	}
+	if( HPMHooks.count.HP_pc_getitemfromcart_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *idx, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getitemfromcart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_getitemfromcart_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &idx, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_cartitem_amount(struct map_session_data *sd, int idx, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_cartitem_amount_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cartitem_amount_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_cartitem_amount_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &idx, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.cartitem_amount(sd, idx, amount);
+	}
+	if( HPMHooks.count.HP_pc_cartitem_amount_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *idx, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cartitem_amount_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_cartitem_amount_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &idx, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_takeitem(struct map_session_data *sd, struct flooritem_data *fitem) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_takeitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct flooritem_data *fitem);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_takeitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_takeitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, fitem);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.takeitem(sd, fitem);
+	}
+	if( HPMHooks.count.HP_pc_takeitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct flooritem_data *fitem);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_takeitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_takeitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, fitem);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_dropitem(struct map_session_data *sd, int n, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_dropitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dropitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_dropitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.dropitem(sd, n, amount);
+	}
+	if( HPMHooks.count.HP_pc_dropitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dropitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_dropitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, &amount);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_isequipped(struct map_session_data *sd, int nameid) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_isequipped_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequipped_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_isequipped_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.isequipped(sd, nameid);
+	}
+	if( HPMHooks.count.HP_pc_isequipped_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequipped_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_isequipped_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_can_Adopt(struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_can_Adopt_pre ) {
+		bool (*preHookFunc) (struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_Adopt_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_can_Adopt_pre[hIndex].func;
+			retVal___ = preHookFunc(p1_sd, p2_sd, b_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.can_Adopt(p1_sd, p2_sd, b_sd);
+	}
+	if( HPMHooks.count.HP_pc_can_Adopt_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_Adopt_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_can_Adopt_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p1_sd, p2_sd, b_sd);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_adoption(struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_adoption_pre ) {
+		bool (*preHookFunc) (struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_adoption_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_adoption_pre[hIndex].func;
+			retVal___ = preHookFunc(p1_sd, p2_sd, b_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.adoption(p1_sd, p2_sd, b_sd);
+	}
+	if( HPMHooks.count.HP_pc_adoption_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_adoption_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_adoption_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p1_sd, p2_sd, b_sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_updateweightstatus(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_updateweightstatus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_updateweightstatus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_updateweightstatus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.updateweightstatus(sd);
+	}
+	if( HPMHooks.count.HP_pc_updateweightstatus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_updateweightstatus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_updateweightstatus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_addautobonus(struct s_autobonus *bonus, char max, const char *bonus_script, short rate, unsigned int dur, short atk_type, const char *o_script, unsigned short pos, bool onskill) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_addautobonus_pre ) {
+		int (*preHookFunc) (struct s_autobonus *bonus, char *max, const char *bonus_script, short *rate, unsigned int *dur, short *atk_type, const char *o_script, unsigned short *pos, bool *onskill);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addautobonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_addautobonus_pre[hIndex].func;
+			retVal___ = preHookFunc(bonus, &max, bonus_script, &rate, &dur, &atk_type, o_script, &pos, &onskill);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.addautobonus(bonus, max, bonus_script, rate, dur, atk_type, o_script, pos, onskill);
+	}
+	if( HPMHooks.count.HP_pc_addautobonus_post ) {
+		int (*postHookFunc) (int retVal___, struct s_autobonus *bonus, char *max, const char *bonus_script, short *rate, unsigned int *dur, short *atk_type, const char *o_script, unsigned short *pos, bool *onskill);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addautobonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_addautobonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bonus, &max, bonus_script, &rate, &dur, &atk_type, o_script, &pos, &onskill);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_exeautobonus(struct map_session_data *sd, struct s_autobonus *bonus) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_exeautobonus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct s_autobonus *bonus);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_exeautobonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_exeautobonus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, bonus);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.exeautobonus(sd, bonus);
+	}
+	if( HPMHooks.count.HP_pc_exeautobonus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_autobonus *bonus);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_exeautobonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_exeautobonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, bonus);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_endautobonus(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_endautobonus_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_endautobonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_endautobonus_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.endautobonus(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_endautobonus_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_endautobonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_endautobonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_delautobonus(struct map_session_data *sd, struct s_autobonus *bonus, char max, bool restore) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_delautobonus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct s_autobonus *bonus, char *max, bool *restore);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delautobonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_delautobonus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, bonus, &max, &restore);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.delautobonus(sd, bonus, max, restore);
+	}
+	if( HPMHooks.count.HP_pc_delautobonus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_autobonus *bonus, char *max, bool *restore);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delautobonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_delautobonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, bonus, &max, &restore);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus(struct map_session_data *sd, int type, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus(sd, type, val);
+	}
+	if( HPMHooks.count.HP_pc_bonus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus2(struct map_session_data *sd, int type, int type2, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus2_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus2_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &type2, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus2(sd, type, type2, val);
+	}
+	if( HPMHooks.count.HP_pc_bonus2_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *type2, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &type2, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus3(struct map_session_data *sd, int type, int type2, int type3, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus3_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *type3, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus3_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus3_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &type2, &type3, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus3(sd, type, type2, type3, val);
+	}
+	if( HPMHooks.count.HP_pc_bonus3_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *type2, int *type3, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus3_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus3_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &type2, &type3, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus4(struct map_session_data *sd, int type, int type2, int type3, int type4, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus4_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus4_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus4_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &type2, &type3, &type4, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus4(sd, type, type2, type3, type4, val);
+	}
+	if( HPMHooks.count.HP_pc_bonus4_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus4_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus4_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &type2, &type3, &type4, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus5(struct map_session_data *sd, int type, int type2, int type3, int type4, int type5, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus5_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *type5, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus5_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus5_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &type2, &type3, &type4, &type5, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus5(sd, type, type2, type3, type4, type5, val);
+	}
+	if( HPMHooks.count.HP_pc_bonus5_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *type5, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus5_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus5_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &type2, &type3, &type4, &type5, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_skill(struct map_session_data *sd, int id, int level, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_skill_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *id, int *level, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_skill_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &id, &level, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.skill(sd, id, level, flag);
+	}
+	if( HPMHooks.count.HP_pc_skill_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *id, int *level, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_skill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &id, &level, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_insert_card(struct map_session_data *sd, int idx_card, int idx_equip) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_insert_card_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *idx_card, int *idx_equip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_insert_card_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_insert_card_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &idx_card, &idx_equip);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.insert_card(sd, idx_card, idx_equip);
+	}
+	if( HPMHooks.count.HP_pc_insert_card_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *idx_card, int *idx_equip);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_insert_card_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_insert_card_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &idx_card, &idx_equip);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_steal_item(struct map_session_data *sd, struct block_list *bl, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_steal_item_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_steal_item_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, bl, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.steal_item(sd, bl, skill_lv);
+	}
+	if( HPMHooks.count.HP_pc_steal_item_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_steal_item_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, bl, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_steal_coin(struct map_session_data *sd, struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_steal_coin_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_coin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_steal_coin_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.steal_coin(sd, bl);
+	}
+	if( HPMHooks.count.HP_pc_steal_coin_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_coin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_steal_coin_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_modifybuyvalue(struct map_session_data *sd, int orig_value) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_modifybuyvalue_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *orig_value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifybuyvalue_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_modifybuyvalue_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &orig_value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.modifybuyvalue(sd, orig_value);
+	}
+	if( HPMHooks.count.HP_pc_modifybuyvalue_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *orig_value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifybuyvalue_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_modifybuyvalue_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &orig_value);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_modifysellvalue(struct map_session_data *sd, int orig_value) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_modifysellvalue_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *orig_value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifysellvalue_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_modifysellvalue_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &orig_value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.modifysellvalue(sd, orig_value);
+	}
+	if( HPMHooks.count.HP_pc_modifysellvalue_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *orig_value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifysellvalue_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_modifysellvalue_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &orig_value);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_follow(struct map_session_data *sd, int target_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_follow_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_follow_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &target_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.follow(sd, target_id);
+	}
+	if( HPMHooks.count.HP_pc_follow_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_follow_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &target_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_stop_following(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_stop_following_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_stop_following_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_stop_following_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.stop_following(sd);
+	}
+	if( HPMHooks.count.HP_pc_stop_following_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_stop_following_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_stop_following_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_pc_maxbaselv(struct map_session_data *sd) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_pc_maxbaselv_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxbaselv_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_maxbaselv_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.maxbaselv(sd);
+	}
+	if( HPMHooks.count.HP_pc_maxbaselv_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxbaselv_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_maxbaselv_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_pc_maxjoblv(struct map_session_data *sd) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_pc_maxjoblv_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxjoblv_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_maxjoblv_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.maxjoblv(sd);
+	}
+	if( HPMHooks.count.HP_pc_maxjoblv_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxjoblv_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_maxjoblv_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkbaselevelup(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkbaselevelup_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkbaselevelup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkbaselevelup_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkbaselevelup(sd);
+	}
+	if( HPMHooks.count.HP_pc_checkbaselevelup_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkbaselevelup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkbaselevelup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkjoblevelup(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkjoblevelup_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkjoblevelup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkjoblevelup_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkjoblevelup(sd);
+	}
+	if( HPMHooks.count.HP_pc_checkjoblevelup_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkjoblevelup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkjoblevelup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_gainexp(struct map_session_data *sd, struct block_list *src, unsigned int base_exp, unsigned int job_exp, bool is_quest) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_gainexp_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct block_list *src, unsigned int *base_exp, unsigned int *job_exp, bool *is_quest);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gainexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_gainexp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, src, &base_exp, &job_exp, &is_quest);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.gainexp(sd, src, base_exp, job_exp, is_quest);
+	}
+	if( HPMHooks.count.HP_pc_gainexp_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *src, unsigned int *base_exp, unsigned int *job_exp, bool *is_quest);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gainexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_gainexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, src, &base_exp, &job_exp, &is_quest);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_pc_nextbaseexp(struct map_session_data *sd) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_pc_nextbaseexp_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextbaseexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_nextbaseexp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.nextbaseexp(sd);
+	}
+	if( HPMHooks.count.HP_pc_nextbaseexp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextbaseexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_nextbaseexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_pc_thisbaseexp(struct map_session_data *sd) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_pc_thisbaseexp_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisbaseexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_thisbaseexp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.thisbaseexp(sd);
+	}
+	if( HPMHooks.count.HP_pc_thisbaseexp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisbaseexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_thisbaseexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_pc_nextjobexp(struct map_session_data *sd) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_pc_nextjobexp_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextjobexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_nextjobexp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.nextjobexp(sd);
+	}
+	if( HPMHooks.count.HP_pc_nextjobexp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextjobexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_nextjobexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_pc_thisjobexp(struct map_session_data *sd) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_pc_thisjobexp_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisjobexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_thisjobexp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.thisjobexp(sd);
+	}
+	if( HPMHooks.count.HP_pc_thisjobexp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisjobexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_thisjobexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_gets_status_point(int level) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_gets_status_point_pre ) {
+		int (*preHookFunc) (int *level);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gets_status_point_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_gets_status_point_pre[hIndex].func;
+			retVal___ = preHookFunc(&level);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.gets_status_point(level);
+	}
+	if( HPMHooks.count.HP_pc_gets_status_point_post ) {
+		int (*postHookFunc) (int retVal___, int *level);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gets_status_point_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_gets_status_point_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &level);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_need_status_point(struct map_session_data *sd, int type, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_need_status_point_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_need_status_point_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_need_status_point_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.need_status_point(sd, type, val);
+	}
+	if( HPMHooks.count.HP_pc_need_status_point_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_need_status_point_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_need_status_point_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_statusup(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_statusup_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_statusup_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.statusup(sd, type);
+	}
+	if( HPMHooks.count.HP_pc_statusup_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_statusup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_statusup2(struct map_session_data *sd, int type, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_statusup2_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_statusup2_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.statusup2(sd, type, val);
+	}
+	if( HPMHooks.count.HP_pc_statusup2_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_statusup2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_skillup(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_skillup_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_skillup_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.skillup(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_pc_skillup_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_skillup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_allskillup(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_allskillup_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_allskillup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_allskillup_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.allskillup(sd);
+	}
+	if( HPMHooks.count.HP_pc_allskillup_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_allskillup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_allskillup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_resetlvl(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_resetlvl_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetlvl_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_resetlvl_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.resetlvl(sd, type);
+	}
+	if( HPMHooks.count.HP_pc_resetlvl_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetlvl_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_resetlvl_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_resetstate(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_resetstate_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetstate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_resetstate_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.resetstate(sd);
+	}
+	if( HPMHooks.count.HP_pc_resetstate_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetstate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_resetstate_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_resetskill(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_resetskill_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_resetskill_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.resetskill(sd, flag);
+	}
+	if( HPMHooks.count.HP_pc_resetskill_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_resetskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_resetfeel(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_resetfeel_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetfeel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_resetfeel_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.resetfeel(sd);
+	}
+	if( HPMHooks.count.HP_pc_resetfeel_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetfeel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_resetfeel_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_resethate(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_resethate_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resethate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_resethate_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.resethate(sd);
+	}
+	if( HPMHooks.count.HP_pc_resethate_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resethate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_resethate_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_equipitem(struct map_session_data *sd, int n, int req_pos) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_equipitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, int *req_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_equipitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, &req_pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.equipitem(sd, n, req_pos);
+	}
+	if( HPMHooks.count.HP_pc_equipitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *req_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_equipitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, &req_pos);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_unequipitem(struct map_session_data *sd, int n, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_unequipitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_unequipitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.unequipitem(sd, n, flag);
+	}
+	if( HPMHooks.count.HP_pc_unequipitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_unequipitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkitem(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkitem(sd);
+	}
+	if( HPMHooks.count.HP_pc_checkitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_useitem(struct map_session_data *sd, int n) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_useitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_useitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_useitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.useitem(sd, n);
+	}
+	if( HPMHooks.count.HP_pc_useitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_useitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_useitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_skillatk_bonus(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_skillatk_bonus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillatk_bonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_skillatk_bonus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.skillatk_bonus(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_pc_skillatk_bonus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillatk_bonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_skillatk_bonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_skillheal_bonus(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_skillheal_bonus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal_bonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_skillheal_bonus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.skillheal_bonus(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_pc_skillheal_bonus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal_bonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_skillheal_bonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_skillheal2_bonus(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_skillheal2_bonus_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal2_bonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_skillheal2_bonus_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.skillheal2_bonus(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_pc_skillheal2_bonus_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal2_bonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_skillheal2_bonus_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_damage(struct map_session_data *sd, struct block_list *src, unsigned int hp, unsigned int sp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_damage_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct block_list *src, unsigned int *hp, unsigned int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_damage_pre[hIndex].func;
+			preHookFunc(sd, src, &hp, &sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.damage(sd, src, hp, sp);
+	}
+	if( HPMHooks.count.HP_pc_damage_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct block_list *src, unsigned int *hp, unsigned int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_damage_post[hIndex].func;
+			postHookFunc(sd, src, &hp, &sp);
+		}
+	}
+	return;
+}
+int HP_pc_dead(struct map_session_data *sd, struct block_list *src) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_dead_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dead_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_dead_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, src);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.dead(sd, src);
+	}
+	if( HPMHooks.count.HP_pc_dead_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dead_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_dead_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, src);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_revive(struct map_session_data *sd, unsigned int hp, unsigned int sp) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_revive_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *hp, unsigned int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_revive_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_revive_pre[hIndex].func;
+			preHookFunc(sd, &hp, &sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.revive(sd, hp, sp);
+	}
+	if( HPMHooks.count.HP_pc_revive_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *hp, unsigned int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_revive_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_revive_post[hIndex].func;
+			postHookFunc(sd, &hp, &sp);
+		}
+	}
+	return;
+}
+void HP_pc_heal(struct map_session_data *sd, unsigned int hp, unsigned int sp, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_heal_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *hp, unsigned int *sp, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_heal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_heal_pre[hIndex].func;
+			preHookFunc(sd, &hp, &sp, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.heal(sd, hp, sp, type);
+	}
+	if( HPMHooks.count.HP_pc_heal_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *hp, unsigned int *sp, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_heal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_heal_post[hIndex].func;
+			postHookFunc(sd, &hp, &sp, &type);
+		}
+	}
+	return;
+}
+int HP_pc_itemheal(struct map_session_data *sd, int itemid, int hp, int sp) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_itemheal_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *itemid, int *hp, int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemheal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_itemheal_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &itemid, &hp, &sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.itemheal(sd, itemid, hp, sp);
+	}
+	if( HPMHooks.count.HP_pc_itemheal_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *itemid, int *hp, int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemheal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_itemheal_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &itemid, &hp, &sp);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_percentheal(struct map_session_data *sd, int hp, int sp) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_percentheal_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *hp, int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_percentheal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_percentheal_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &hp, &sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.percentheal(sd, hp, sp);
+	}
+	if( HPMHooks.count.HP_pc_percentheal_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *hp, int *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_percentheal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_percentheal_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &hp, &sp);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_jobchange(struct map_session_data *sd, int job, int upper) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_jobchange_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *job, int *upper);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_jobchange_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &job, &upper);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.jobchange(sd, job, upper);
+	}
+	if( HPMHooks.count.HP_pc_jobchange_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *job, int *upper);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_jobchange_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &job, &upper);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setoption(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setoption_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setoption_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setoption_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setoption(sd, type);
+	}
+	if( HPMHooks.count.HP_pc_setoption_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setoption_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setoption_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setcart(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setcart_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setcart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setcart_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setcart(sd, type);
+	}
+	if( HPMHooks.count.HP_pc_setcart_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setcart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setcart_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setfalcon(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setfalcon_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setfalcon_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setfalcon_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setfalcon(sd, flag);
+	}
+	if( HPMHooks.count.HP_pc_setfalcon_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setfalcon_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setfalcon_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setriding(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setriding_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setriding_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setriding_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setriding(sd, flag);
+	}
+	if( HPMHooks.count.HP_pc_setriding_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setriding_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setriding_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setmadogear(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setmadogear_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setmadogear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setmadogear_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setmadogear(sd, flag);
+	}
+	if( HPMHooks.count.HP_pc_setmadogear_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setmadogear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setmadogear_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_changelook(struct map_session_data *sd, int type, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_changelook_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_changelook_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_changelook_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.changelook(sd, type, val);
+	}
+	if( HPMHooks.count.HP_pc_changelook_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_changelook_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_changelook_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_equiplookall(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_equiplookall_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equiplookall_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_equiplookall_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.equiplookall(sd);
+	}
+	if( HPMHooks.count.HP_pc_equiplookall_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equiplookall_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_equiplookall_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_readparam(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_readparam_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readparam_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_readparam_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.readparam(sd, type);
+	}
+	if( HPMHooks.count.HP_pc_readparam_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readparam_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_readparam_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setparam(struct map_session_data *sd, int type, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setparam_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setparam_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setparam_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setparam(sd, type, val);
+	}
+	if( HPMHooks.count.HP_pc_setparam_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setparam_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setparam_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_readreg(struct map_session_data *sd, int reg) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_readreg_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *reg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readreg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_readreg_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &reg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.readreg(sd, reg);
+	}
+	if( HPMHooks.count.HP_pc_readreg_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *reg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readreg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_readreg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &reg);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setreg(struct map_session_data *sd, int reg, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setreg_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *reg, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setreg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setreg_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &reg, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setreg(sd, reg, val);
+	}
+	if( HPMHooks.count.HP_pc_setreg_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *reg, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setreg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setreg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &reg, &val);
+		}
+	}
+	return retVal___;
+}
+char* HP_pc_readregstr(struct map_session_data *sd, int reg) {
+	int hIndex = 0;
+	char* retVal___ = NULL;
+	if( HPMHooks.count.HP_pc_readregstr_pre ) {
+		char* (*preHookFunc) (struct map_session_data *sd, int *reg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregstr_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_readregstr_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &reg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.readregstr(sd, reg);
+	}
+	if( HPMHooks.count.HP_pc_readregstr_post ) {
+		char* (*postHookFunc) (char* retVal___, struct map_session_data *sd, int *reg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregstr_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_readregstr_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &reg);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setregstr(struct map_session_data *sd, int reg, const char *str) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setregstr_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *reg, const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregstr_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setregstr_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &reg, str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setregstr(sd, reg, str);
+	}
+	if( HPMHooks.count.HP_pc_setregstr_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *reg, const char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregstr_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setregstr_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &reg, str);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_readregistry(struct map_session_data *sd, const char *reg, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_readregistry_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *reg, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_readregistry_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, reg, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.readregistry(sd, reg, type);
+	}
+	if( HPMHooks.count.HP_pc_readregistry_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *reg, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_readregistry_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, reg, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setregistry(struct map_session_data *sd, const char *reg, int val, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setregistry_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *reg, int *val, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setregistry_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, reg, &val, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setregistry(sd, reg, val, type);
+	}
+	if( HPMHooks.count.HP_pc_setregistry_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *reg, int *val, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setregistry_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, reg, &val, &type);
+		}
+	}
+	return retVal___;
+}
+char* HP_pc_readregistry_str(struct map_session_data *sd, const char *reg, int type) {
+	int hIndex = 0;
+	char* retVal___ = NULL;
+	if( HPMHooks.count.HP_pc_readregistry_str_pre ) {
+		char* (*preHookFunc) (struct map_session_data *sd, const char *reg, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_readregistry_str_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, reg, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.readregistry_str(sd, reg, type);
+	}
+	if( HPMHooks.count.HP_pc_readregistry_str_post ) {
+		char* (*postHookFunc) (char* retVal___, struct map_session_data *sd, const char *reg, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_readregistry_str_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, reg, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setregistry_str(struct map_session_data *sd, const char *reg, const char *val, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setregistry_str_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *reg, const char *val, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setregistry_str_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, reg, val, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setregistry_str(sd, reg, val, type);
+	}
+	if( HPMHooks.count.HP_pc_setregistry_str_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *reg, const char *val, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setregistry_str_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, reg, val, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_addeventtimer(struct map_session_data *sd, int tick, const char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_addeventtimer_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *tick, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_addeventtimer_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &tick, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.addeventtimer(sd, tick, name);
+	}
+	if( HPMHooks.count.HP_pc_addeventtimer_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *tick, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_addeventtimer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &tick, name);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_deleventtimer(struct map_session_data *sd, const char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_deleventtimer_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_deleventtimer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_deleventtimer_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.deleventtimer(sd, name);
+	}
+	if( HPMHooks.count.HP_pc_deleventtimer_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_deleventtimer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_deleventtimer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_cleareventtimer(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_cleareventtimer_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cleareventtimer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_cleareventtimer_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.cleareventtimer(sd);
+	}
+	if( HPMHooks.count.HP_pc_cleareventtimer_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cleareventtimer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_cleareventtimer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_addeventtimercount(struct map_session_data *sd, const char *name, int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_addeventtimercount_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, const char *name, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimercount_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_addeventtimercount_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.addeventtimercount(sd, name, tick);
+	}
+	if( HPMHooks.count.HP_pc_addeventtimercount_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimercount_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_addeventtimercount_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_calc_pvprank(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_calc_pvprank_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_pvprank_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_calc_pvprank_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.calc_pvprank(sd);
+	}
+	if( HPMHooks.count.HP_pc_calc_pvprank_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_pvprank_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_calc_pvprank_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_calc_pvprank_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_calc_pvprank_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_pvprank_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_calc_pvprank_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.calc_pvprank_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_calc_pvprank_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_pvprank_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_calc_pvprank_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_ismarried(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_ismarried_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_ismarried_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_ismarried_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.ismarried(sd);
+	}
+	if( HPMHooks.count.HP_pc_ismarried_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_ismarried_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_ismarried_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_marriage(struct map_session_data *sd, struct map_session_data *dstsd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_marriage_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_marriage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_marriage_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, dstsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.marriage(sd, dstsd);
+	}
+	if( HPMHooks.count.HP_pc_marriage_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *dstsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_marriage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_marriage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, dstsd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_divorce(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_divorce_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_divorce_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_divorce_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.divorce(sd);
+	}
+	if( HPMHooks.count.HP_pc_divorce_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_divorce_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_divorce_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_pc_get_partner(struct map_session_data *sd) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_pc_get_partner_pre ) {
+		struct map_session_data* (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_partner_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_get_partner_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.get_partner(sd);
+	}
+	if( HPMHooks.count.HP_pc_get_partner_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_partner_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_get_partner_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_pc_get_father(struct map_session_data *sd) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_pc_get_father_pre ) {
+		struct map_session_data* (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_father_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_get_father_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.get_father(sd);
+	}
+	if( HPMHooks.count.HP_pc_get_father_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_father_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_get_father_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_pc_get_mother(struct map_session_data *sd) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_pc_get_mother_pre ) {
+		struct map_session_data* (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_mother_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_get_mother_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.get_mother(sd);
+	}
+	if( HPMHooks.count.HP_pc_get_mother_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_mother_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_get_mother_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+struct map_session_data* HP_pc_get_child(struct map_session_data *sd) {
+	int hIndex = 0;
+	struct map_session_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_pc_get_child_pre ) {
+		struct map_session_data* (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_child_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_get_child_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.get_child(sd);
+	}
+	if( HPMHooks.count.HP_pc_get_child_post ) {
+		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_child_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_get_child_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_bleeding(struct map_session_data *sd, unsigned int diff_tick) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_bleeding_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *diff_tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bleeding_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bleeding_pre[hIndex].func;
+			preHookFunc(sd, &diff_tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.bleeding(sd, diff_tick);
+	}
+	if( HPMHooks.count.HP_pc_bleeding_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *diff_tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bleeding_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bleeding_post[hIndex].func;
+			postHookFunc(sd, &diff_tick);
+		}
+	}
+	return;
+}
+void HP_pc_regen(struct map_session_data *sd, unsigned int diff_tick) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_regen_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *diff_tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_regen_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_regen_pre[hIndex].func;
+			preHookFunc(sd, &diff_tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.regen(sd, diff_tick);
+	}
+	if( HPMHooks.count.HP_pc_regen_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *diff_tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_regen_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_regen_post[hIndex].func;
+			postHookFunc(sd, &diff_tick);
+		}
+	}
+	return;
+}
+void HP_pc_setstand(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_setstand_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstand_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setstand_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.setstand(sd);
+	}
+	if( HPMHooks.count.HP_pc_setstand_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstand_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setstand_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_pc_candrop(struct map_session_data *sd, struct item *item) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_candrop_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_candrop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_candrop_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, item);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.candrop(sd, item);
+	}
+	if( HPMHooks.count.HP_pc_candrop_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_candrop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_candrop_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, item);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_jobid2mapid(unsigned short b_class) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_jobid2mapid_pre ) {
+		int (*preHookFunc) (unsigned short *b_class);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobid2mapid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_jobid2mapid_pre[hIndex].func;
+			retVal___ = preHookFunc(&b_class);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.jobid2mapid(b_class);
+	}
+	if( HPMHooks.count.HP_pc_jobid2mapid_post ) {
+		int (*postHookFunc) (int retVal___, unsigned short *b_class);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobid2mapid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_jobid2mapid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &b_class);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_mapid2jobid(unsigned short class_, int sex) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_mapid2jobid_pre ) {
+		int (*preHookFunc) (unsigned short *class_, int *sex);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_mapid2jobid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_mapid2jobid_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_, &sex);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.mapid2jobid(class_, sex);
+	}
+	if( HPMHooks.count.HP_pc_mapid2jobid_post ) {
+		int (*postHookFunc) (int retVal___, unsigned short *class_, int *sex);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_mapid2jobid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_mapid2jobid_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_, &sex);
+		}
+	}
+	return retVal___;
+}
+const char* HP_pc_job_name(int class_) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_pc_job_name_pre ) {
+		const char* (*preHookFunc) (int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_job_name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_job_name_pre[hIndex].func;
+			retVal___ = preHookFunc(&class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.job_name(class_);
+	}
+	if( HPMHooks.count.HP_pc_job_name_post ) {
+		const char* (*postHookFunc) (const char* retVal___, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_job_name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_job_name_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &class_);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_setinvincibletimer(struct map_session_data *sd, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_setinvincibletimer_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinvincibletimer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setinvincibletimer_pre[hIndex].func;
+			preHookFunc(sd, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.setinvincibletimer(sd, val);
+	}
+	if( HPMHooks.count.HP_pc_setinvincibletimer_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinvincibletimer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setinvincibletimer_post[hIndex].func;
+			postHookFunc(sd, &val);
+		}
+	}
+	return;
+}
+void HP_pc_delinvincibletimer(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_delinvincibletimer_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delinvincibletimer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_delinvincibletimer_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.delinvincibletimer(sd);
+	}
+	if( HPMHooks.count.HP_pc_delinvincibletimer_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delinvincibletimer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_delinvincibletimer_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_pc_addspiritball(struct map_session_data *sd, int interval, int max) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_addspiritball_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *interval, int *max);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addspiritball_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_addspiritball_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &interval, &max);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.addspiritball(sd, interval, max);
+	}
+	if( HPMHooks.count.HP_pc_addspiritball_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *interval, int *max);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addspiritball_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_addspiritball_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &interval, &max);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_delspiritball(struct map_session_data *sd, int count, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_delspiritball_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *count, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delspiritball_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_delspiritball_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &count, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.delspiritball(sd, count, type);
+	}
+	if( HPMHooks.count.HP_pc_delspiritball_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *count, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delspiritball_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_delspiritball_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &count, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_addfame(struct map_session_data *sd, int count) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_addfame_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addfame_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_addfame_pre[hIndex].func;
+			preHookFunc(sd, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.addfame(sd, count);
+	}
+	if( HPMHooks.count.HP_pc_addfame_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addfame_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_addfame_post[hIndex].func;
+			postHookFunc(sd, &count);
+		}
+	}
+	return;
+}
+unsigned char HP_pc_famerank(int char_id, int job) {
+	int hIndex = 0;
+	unsigned char retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned char));
+	if( HPMHooks.count.HP_pc_famerank_pre ) {
+		unsigned char (*preHookFunc) (int *char_id, int *job);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_famerank_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_famerank_pre[hIndex].func;
+			retVal___ = preHookFunc(&char_id, &job);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.famerank(char_id, job);
+	}
+	if( HPMHooks.count.HP_pc_famerank_post ) {
+		unsigned char (*postHookFunc) (unsigned char retVal___, int *char_id, int *job);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_famerank_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_famerank_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &char_id, &job);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_set_hate_mob(struct map_session_data *sd, int pos, struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_set_hate_mob_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *pos, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_hate_mob_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_set_hate_mob_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &pos, bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.set_hate_mob(sd, pos, bl);
+	}
+	if( HPMHooks.count.HP_pc_set_hate_mob_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *pos, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_hate_mob_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_set_hate_mob_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &pos, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_readdb(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_readdb_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_readdb_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.readdb();
+	}
+	if( HPMHooks.count.HP_pc_readdb_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_readdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_map_day_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_map_day_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_map_day_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_map_day_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.map_day_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_map_day_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_map_day_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_map_day_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_map_night_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_map_night_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_map_night_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_map_night_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.map_night_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_map_night_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_map_night_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_map_night_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_inventory_rentals(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_inventory_rentals_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rentals_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_inventory_rentals_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.inventory_rentals(sd);
+	}
+	if( HPMHooks.count.HP_pc_inventory_rentals_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rentals_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_inventory_rentals_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_pc_inventory_rental_clear(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_inventory_rental_clear_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_inventory_rental_clear_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.inventory_rental_clear(sd);
+	}
+	if( HPMHooks.count.HP_pc_inventory_rental_clear_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_inventory_rental_clear_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_inventory_rental_add(struct map_session_data *sd, int seconds) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_inventory_rental_add_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *seconds);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_inventory_rental_add_pre[hIndex].func;
+			preHookFunc(sd, &seconds);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.inventory_rental_add(sd, seconds);
+	}
+	if( HPMHooks.count.HP_pc_inventory_rental_add_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *seconds);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_inventory_rental_add_post[hIndex].func;
+			postHookFunc(sd, &seconds);
+		}
+	}
+	return;
+}
+int HP_pc_disguise(struct map_session_data *sd, int class_) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_disguise_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_disguise_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_disguise_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.disguise(sd, class_);
+	}
+	if( HPMHooks.count.HP_pc_disguise_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_disguise_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_disguise_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &class_);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_isautolooting(struct map_session_data *sd, int nameid) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_isautolooting_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isautolooting_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_isautolooting_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.isautolooting(sd, nameid);
+	}
+	if( HPMHooks.count.HP_pc_isautolooting_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isautolooting_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_isautolooting_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_overheat(struct map_session_data *sd, int val) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_overheat_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_overheat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_overheat_pre[hIndex].func;
+			preHookFunc(sd, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.overheat(sd, val);
+	}
+	if( HPMHooks.count.HP_pc_overheat_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_overheat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_overheat_post[hIndex].func;
+			postHookFunc(sd, &val);
+		}
+	}
+	return;
+}
+int HP_pc_banding(struct map_session_data *sd, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_banding_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_banding_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_banding_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.banding(sd, skill_lv);
+	}
+	if( HPMHooks.count.HP_pc_banding_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_banding_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_banding_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_itemcd_do(struct map_session_data *sd, bool load) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_itemcd_do_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, bool *load);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemcd_do_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_itemcd_do_pre[hIndex].func;
+			preHookFunc(sd, &load);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.itemcd_do(sd, load);
+	}
+	if( HPMHooks.count.HP_pc_itemcd_do_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, bool *load);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemcd_do_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_itemcd_do_post[hIndex].func;
+			postHookFunc(sd, &load);
+		}
+	}
+	return;
+}
+int HP_pc_load_combo(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_load_combo_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_load_combo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_load_combo_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.load_combo(sd);
+	}
+	if( HPMHooks.count.HP_pc_load_combo_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_load_combo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_load_combo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_add_charm(struct map_session_data *sd, int interval, int max, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_add_charm_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *interval, int *max, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_add_charm_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_add_charm_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &interval, &max, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.add_charm(sd, interval, max, type);
+	}
+	if( HPMHooks.count.HP_pc_add_charm_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *interval, int *max, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_add_charm_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_add_charm_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &interval, &max, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_del_charm(struct map_session_data *sd, int count, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_del_charm_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *count, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_del_charm_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_del_charm_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &count, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.del_charm(sd, count, type);
+	}
+	if( HPMHooks.count.HP_pc_del_charm_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *count, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_del_charm_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_del_charm_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &count, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_baselevelchanged(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_baselevelchanged_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_baselevelchanged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_baselevelchanged_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.baselevelchanged(sd);
+	}
+	if( HPMHooks.count.HP_pc_baselevelchanged_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_baselevelchanged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_baselevelchanged_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_pc_level_penalty_mod(int diff, unsigned char race, unsigned short mode, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_level_penalty_mod_pre ) {
+		int (*preHookFunc) (int *diff, unsigned char *race, unsigned short *mode, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_level_penalty_mod_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_level_penalty_mod_pre[hIndex].func;
+			retVal___ = preHookFunc(&diff, &race, &mode, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.level_penalty_mod(diff, race, mode, type);
+	}
+	if( HPMHooks.count.HP_pc_level_penalty_mod_post ) {
+		int (*postHookFunc) (int retVal___, int *diff, unsigned char *race, unsigned short *mode, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_level_penalty_mod_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_level_penalty_mod_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &diff, &race, &mode, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_calc_skillpoint(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_calc_skillpoint_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skillpoint_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_calc_skillpoint_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.calc_skillpoint(sd);
+	}
+	if( HPMHooks.count.HP_pc_calc_skillpoint_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skillpoint_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_calc_skillpoint_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_invincible_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_invincible_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_invincible_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_invincible_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.invincible_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_invincible_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_invincible_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_invincible_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_spiritball_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_spiritball_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_spiritball_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_spiritball_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.spiritball_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_spiritball_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_spiritball_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_spiritball_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_check_banding(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_check_banding_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_banding_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_pc_check_banding_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.pc.check_banding(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_pc_check_banding_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_banding_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_pc_check_banding_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_inventory_rental_end(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_inventory_rental_end_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_inventory_rental_end_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.inventory_rental_end(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_inventory_rental_end_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_inventory_rental_end_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_check_skilltree(struct map_session_data *sd, int skill_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_check_skilltree_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_skilltree_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_check_skilltree_pre[hIndex].func;
+			preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.check_skilltree(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_pc_check_skilltree_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_skilltree_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_check_skilltree_post[hIndex].func;
+			postHookFunc(sd, &skill_id);
+		}
+	}
+	return;
+}
+int HP_pc_bonus_autospell(struct s_autospell *spell, int max, short id, short lv, short rate, short flag, short card_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus_autospell_pre ) {
+		int (*preHookFunc) (struct s_autospell *spell, int *max, short *id, short *lv, short *rate, short *flag, short *card_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus_autospell_pre[hIndex].func;
+			retVal___ = preHookFunc(spell, &max, &id, &lv, &rate, &flag, &card_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus_autospell(spell, max, id, lv, rate, flag, card_id);
+	}
+	if( HPMHooks.count.HP_pc_bonus_autospell_post ) {
+		int (*postHookFunc) (int retVal___, struct s_autospell *spell, int *max, short *id, short *lv, short *rate, short *flag, short *card_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus_autospell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, spell, &max, &id, &lv, &rate, &flag, &card_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus_autospell_onskill(struct s_autospell *spell, int max, short src_skill, short id, short lv, short rate, short card_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus_autospell_onskill_pre ) {
+		int (*preHookFunc) (struct s_autospell *spell, int *max, short *src_skill, short *id, short *lv, short *rate, short *card_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_onskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus_autospell_onskill_pre[hIndex].func;
+			retVal___ = preHookFunc(spell, &max, &src_skill, &id, &lv, &rate, &card_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus_autospell_onskill(spell, max, src_skill, id, lv, rate, card_id);
+	}
+	if( HPMHooks.count.HP_pc_bonus_autospell_onskill_post ) {
+		int (*postHookFunc) (int retVal___, struct s_autospell *spell, int *max, short *src_skill, short *id, short *lv, short *rate, short *card_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_onskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus_autospell_onskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, spell, &max, &src_skill, &id, &lv, &rate, &card_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus_addeff(struct s_addeffect *effect, int max, enum sc_type id, short rate, short arrow_rate, unsigned char flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus_addeff_pre ) {
+		int (*preHookFunc) (struct s_addeffect *effect, int *max, enum sc_type *id, short *rate, short *arrow_rate, unsigned char *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus_addeff_pre[hIndex].func;
+			retVal___ = preHookFunc(effect, &max, &id, &rate, &arrow_rate, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus_addeff(effect, max, id, rate, arrow_rate, flag);
+	}
+	if( HPMHooks.count.HP_pc_bonus_addeff_post ) {
+		int (*postHookFunc) (int retVal___, struct s_addeffect *effect, int *max, enum sc_type *id, short *rate, short *arrow_rate, unsigned char *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus_addeff_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, effect, &max, &id, &rate, &arrow_rate, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus_addeff_onskill(struct s_addeffectonskill *effect, int max, enum sc_type id, short rate, short skill_id, unsigned char target) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus_addeff_onskill_pre ) {
+		int (*preHookFunc) (struct s_addeffectonskill *effect, int *max, enum sc_type *id, short *rate, short *skill_id, unsigned char *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_onskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus_addeff_onskill_pre[hIndex].func;
+			retVal___ = preHookFunc(effect, &max, &id, &rate, &skill_id, &target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus_addeff_onskill(effect, max, id, rate, skill_id, target);
+	}
+	if( HPMHooks.count.HP_pc_bonus_addeff_onskill_post ) {
+		int (*postHookFunc) (int retVal___, struct s_addeffectonskill *effect, int *max, enum sc_type *id, short *rate, short *skill_id, unsigned char *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_onskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus_addeff_onskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, effect, &max, &id, &rate, &skill_id, &target);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_bonus_item_drop(struct s_add_drop *drop, const short max, short id, short group, int race, int rate) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_bonus_item_drop_pre ) {
+		int (*preHookFunc) (struct s_add_drop *drop, const short *max, short *id, short *group, int *race, int *rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_item_drop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_bonus_item_drop_pre[hIndex].func;
+			retVal___ = preHookFunc(drop, &max, &id, &group, &race, &rate);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.bonus_item_drop(drop, max, id, group, race, rate);
+	}
+	if( HPMHooks.count.HP_pc_bonus_item_drop_post ) {
+		int (*postHookFunc) (int retVal___, struct s_add_drop *drop, const short *max, short *id, short *group, int *race, int *rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_item_drop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_bonus_item_drop_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, drop, &max, &id, &group, &race, &rate);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_calcexp(struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_calcexp_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_calcexp_pre[hIndex].func;
+			preHookFunc(sd, base_exp, job_exp, src);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.calcexp(sd, base_exp, job_exp, src);
+	}
+	if( HPMHooks.count.HP_pc_calcexp_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_calcexp_post[hIndex].func;
+			postHookFunc(sd, base_exp, job_exp, src);
+		}
+	}
+	return;
+}
+int HP_pc_respawn_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_respawn_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_respawn_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.respawn_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_respawn_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_respawn_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_jobchange_killclone(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_jobchange_killclone_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_killclone_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_pc_jobchange_killclone_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.pc.jobchange_killclone(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_pc_jobchange_killclone_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_killclone_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_pc_jobchange_killclone_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_getstat(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_getstat_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getstat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_getstat_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.getstat(sd, type);
+	}
+	if( HPMHooks.count.HP_pc_getstat_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getstat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_getstat_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_setstat(struct map_session_data *sd, int type, int val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_setstat_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstat_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_setstat_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type, &val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.setstat(sd, type, val);
+	}
+	if( HPMHooks.count.HP_pc_setstat_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstat_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_setstat_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type, &val);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_eventtimer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_eventtimer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_eventtimer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_eventtimer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.eventtimer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_eventtimer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_eventtimer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_eventtimer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_daynight_timer_sub(struct map_session_data *sd, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_daynight_timer_sub_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_daynight_timer_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_pc_daynight_timer_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.pc.daynight_timer_sub(sd, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_pc_daynight_timer_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_daynight_timer_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_pc_daynight_timer_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_charm_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_charm_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_charm_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_charm_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.charm_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_charm_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_charm_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_charm_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+bool HP_pc_readdb_levelpenalty(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_pc_readdb_levelpenalty_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_levelpenalty_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_readdb_levelpenalty_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.readdb_levelpenalty(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_pc_readdb_levelpenalty_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_levelpenalty_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_readdb_levelpenalty_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_autosave(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_autosave_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autosave_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_autosave_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.autosave(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_autosave_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autosave_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_autosave_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_follow_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_follow_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_follow_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.follow_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pc_follow_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_follow_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+void HP_pc_read_skill_tree(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pc_read_skill_tree_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_read_skill_tree_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_read_skill_tree_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pc.read_skill_tree();
+	}
+	if( HPMHooks.count.HP_pc_read_skill_tree_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_read_skill_tree_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_read_skill_tree_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_pc_isUseitem(struct map_session_data *sd, int n) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_isUseitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isUseitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_isUseitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.isUseitem(sd, n);
+	}
+	if( HPMHooks.count.HP_pc_isUseitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isUseitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_isUseitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_show_steal(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_show_steal_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_show_steal_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_pc_show_steal_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.pc.show_steal(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_pc_show_steal_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_show_steal_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_pc_show_steal_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_checkcombo(struct map_session_data *sd, struct item_data *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_checkcombo_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkcombo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_checkcombo_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.checkcombo(sd, data);
+	}
+	if( HPMHooks.count.HP_pc_checkcombo_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkcombo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_checkcombo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, data);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_calcweapontype(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_calcweapontype_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcweapontype_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_calcweapontype_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.calcweapontype(sd);
+	}
+	if( HPMHooks.count.HP_pc_calcweapontype_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcweapontype_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_calcweapontype_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pc_removecombo(struct map_session_data *sd, struct item_data *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pc_removecombo_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_removecombo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pc_removecombo_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pc.removecombo(sd, data);
+	}
+	if( HPMHooks.count.HP_pc_removecombo_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_removecombo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pc_removecombo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, data);
+		}
+	}
+	return retVal___;
+}
+/* pet */
+int HP_pet_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.init();
+	}
+	if( HPMHooks.count.HP_pet_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_final(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_final_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_final_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.final();
+	}
+	if( HPMHooks.count.HP_pet_final_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_hungry_val(struct pet_data *pd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_hungry_val_pre ) {
+		int (*preHookFunc) (struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_val_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_hungry_val_pre[hIndex].func;
+			retVal___ = preHookFunc(pd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.hungry_val(pd);
+	}
+	if( HPMHooks.count.HP_pet_hungry_val_post ) {
+		int (*postHookFunc) (int retVal___, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_val_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_hungry_val_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, pd);
+		}
+	}
+	return retVal___;
+}
+void HP_pet_set_intimate(struct pet_data *pd, int value) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_pet_set_intimate_pre ) {
+		void (*preHookFunc) (struct pet_data *pd, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_set_intimate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_set_intimate_pre[hIndex].func;
+			preHookFunc(pd, &value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.pet.set_intimate(pd, value);
+	}
+	if( HPMHooks.count.HP_pet_set_intimate_post ) {
+		void (*postHookFunc) (struct pet_data *pd, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_set_intimate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_set_intimate_post[hIndex].func;
+			postHookFunc(pd, &value);
+		}
+	}
+	return;
+}
+int HP_pet_create_egg(struct map_session_data *sd, int item_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_create_egg_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *item_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_create_egg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_create_egg_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &item_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.create_egg(sd, item_id);
+	}
+	if( HPMHooks.count.HP_pet_create_egg_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *item_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_create_egg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_create_egg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &item_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_unlocktarget(struct pet_data *pd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_unlocktarget_pre ) {
+		int (*preHookFunc) (struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unlocktarget_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_unlocktarget_pre[hIndex].func;
+			retVal___ = preHookFunc(pd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.unlocktarget(pd);
+	}
+	if( HPMHooks.count.HP_pet_unlocktarget_post ) {
+		int (*postHookFunc) (int retVal___, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unlocktarget_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_unlocktarget_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, pd);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_attackskill(struct pet_data *pd, int target_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_attackskill_pre ) {
+		int (*preHookFunc) (struct pet_data *pd, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_attackskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_attackskill_pre[hIndex].func;
+			retVal___ = preHookFunc(pd, &target_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.attackskill(pd, target_id);
+	}
+	if( HPMHooks.count.HP_pet_attackskill_post ) {
+		int (*postHookFunc) (int retVal___, struct pet_data *pd, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_attackskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_attackskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, pd, &target_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_target_check(struct map_session_data *sd, struct block_list *bl, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_target_check_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_target_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_target_check_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.target_check(sd, bl, type);
+	}
+	if( HPMHooks.count.HP_pet_target_check_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_target_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_target_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, bl, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_sc_check(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_sc_check_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_sc_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_sc_check_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.sc_check(sd, type);
+	}
+	if( HPMHooks.count.HP_pet_sc_check_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_sc_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_sc_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_hungry(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_hungry_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_hungry_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.hungry(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pet_hungry_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_hungry_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_search_petDB_index(int key, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_search_petDB_index_pre ) {
+		int (*preHookFunc) (int *key, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_search_petDB_index_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_search_petDB_index_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.search_petDB_index(key, type);
+	}
+	if( HPMHooks.count.HP_pet_search_petDB_index_post ) {
+		int (*postHookFunc) (int retVal___, int *key, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_search_petDB_index_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_search_petDB_index_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_hungry_timer_delete(struct pet_data *pd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_hungry_timer_delete_pre ) {
+		int (*preHookFunc) (struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_timer_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_hungry_timer_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(pd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.hungry_timer_delete(pd);
+	}
+	if( HPMHooks.count.HP_pet_hungry_timer_delete_post ) {
+		int (*postHookFunc) (int retVal___, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_timer_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_hungry_timer_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, pd);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_performance(struct map_session_data *sd, struct pet_data *pd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_performance_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_performance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_performance_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, pd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.performance(sd, pd);
+	}
+	if( HPMHooks.count.HP_pet_performance_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_performance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_performance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, pd);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_return_egg(struct map_session_data *sd, struct pet_data *pd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_return_egg_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_return_egg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_return_egg_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, pd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.return_egg(sd, pd);
+	}
+	if( HPMHooks.count.HP_pet_return_egg_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_return_egg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_return_egg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, pd);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_data_init(struct map_session_data *sd, struct s_pet *petinfo) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_data_init_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct s_pet *petinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_data_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_data_init_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, petinfo);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.data_init(sd, petinfo);
+	}
+	if( HPMHooks.count.HP_pet_data_init_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_pet *petinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_data_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_data_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, petinfo);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_birth_process(struct map_session_data *sd, struct s_pet *petinfo) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_birth_process_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct s_pet *petinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_birth_process_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_birth_process_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, petinfo);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.birth_process(sd, petinfo);
+	}
+	if( HPMHooks.count.HP_pet_birth_process_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_pet *petinfo);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_birth_process_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_birth_process_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, petinfo);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_recv_petdata(int account_id, struct s_pet *p, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_recv_petdata_pre ) {
+		int (*preHookFunc) (int *account_id, struct s_pet *p, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recv_petdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_recv_petdata_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, p, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.recv_petdata(account_id, p, flag);
+	}
+	if( HPMHooks.count.HP_pet_recv_petdata_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, struct s_pet *p, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recv_petdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_recv_petdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, p, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_select_egg(struct map_session_data *sd, short egg_index) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_select_egg_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, short *egg_index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_select_egg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_select_egg_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &egg_index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.select_egg(sd, egg_index);
+	}
+	if( HPMHooks.count.HP_pet_select_egg_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, short *egg_index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_select_egg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_select_egg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &egg_index);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_catch_process1(struct map_session_data *sd, int target_class) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_catch_process1_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *target_class);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process1_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_catch_process1_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &target_class);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.catch_process1(sd, target_class);
+	}
+	if( HPMHooks.count.HP_pet_catch_process1_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *target_class);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process1_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_catch_process1_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &target_class);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_catch_process2(struct map_session_data *sd, int target_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_catch_process2_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_catch_process2_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &target_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.catch_process2(sd, target_id);
+	}
+	if( HPMHooks.count.HP_pet_catch_process2_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_catch_process2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &target_id);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_get_egg(int account_id, int pet_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_get_egg_pre ) {
+		int (*preHookFunc) (int *account_id, int *pet_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_get_egg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_get_egg_pre[hIndex].func;
+			retVal___ = preHookFunc(&account_id, &pet_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.get_egg(account_id, pet_id, flag);
+	}
+	if( HPMHooks.count.HP_pet_get_egg_post ) {
+		int (*postHookFunc) (int retVal___, int *account_id, int *pet_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_get_egg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_get_egg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &account_id, &pet_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_unequipitem(struct map_session_data *sd, struct pet_data *pd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_unequipitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unequipitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_unequipitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, pd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.unequipitem(sd, pd);
+	}
+	if( HPMHooks.count.HP_pet_unequipitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unequipitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_unequipitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, pd);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_food(struct map_session_data *sd, struct pet_data *pd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_food_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_food_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_food_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, pd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.food(sd, pd);
+	}
+	if( HPMHooks.count.HP_pet_food_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct pet_data *pd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_food_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_food_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, pd);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_ai_sub_hard_lootsearch(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_lootsearch_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.pet.ai_sub_hard_lootsearch(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_lootsearch_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_menu(struct map_session_data *sd, int menunum) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_menu_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *menunum);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_menu_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_menu_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &menunum);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.menu(sd, menunum);
+	}
+	if( HPMHooks.count.HP_pet_menu_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *menunum);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_menu_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_menu_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &menunum);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_change_name(struct map_session_data *sd, char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_change_name_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_change_name_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.change_name(sd, name);
+	}
+	if( HPMHooks.count.HP_pet_change_name_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_change_name_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_change_name_ack(struct map_session_data *sd, char *name, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_change_name_ack_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, char *name, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_change_name_ack_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.change_name_ack(sd, name, flag);
+	}
+	if( HPMHooks.count.HP_pet_change_name_ack_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, char *name, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_change_name_ack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_equipitem(struct map_session_data *sd, int index) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_equipitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_equipitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_equipitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.equipitem(sd, index);
+	}
+	if( HPMHooks.count.HP_pet_equipitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_equipitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_equipitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_randomwalk(struct pet_data *pd, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_randomwalk_pre ) {
+		int (*preHookFunc) (struct pet_data *pd, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_randomwalk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_randomwalk_pre[hIndex].func;
+			retVal___ = preHookFunc(pd, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.randomwalk(pd, tick);
+	}
+	if( HPMHooks.count.HP_pet_randomwalk_post ) {
+		int (*postHookFunc) (int retVal___, struct pet_data *pd, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_randomwalk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_randomwalk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, pd, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_ai_sub_hard(struct pet_data *pd, struct map_session_data *sd, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_ai_sub_hard_pre ) {
+		int (*preHookFunc) (struct pet_data *pd, struct map_session_data *sd, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_pre[hIndex].func;
+			retVal___ = preHookFunc(pd, sd, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.ai_sub_hard(pd, sd, tick);
+	}
+	if( HPMHooks.count.HP_pet_ai_sub_hard_post ) {
+		int (*postHookFunc) (int retVal___, struct pet_data *pd, struct map_session_data *sd, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, pd, sd, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_ai_sub_foreachclient_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_foreachclient_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_pet_ai_sub_foreachclient_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.pet.ai_sub_foreachclient(sd, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_pet_ai_sub_foreachclient_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_foreachclient_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_pet_ai_sub_foreachclient_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_ai_hard(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_ai_hard_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_hard_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_ai_hard_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.ai_hard(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pet_ai_hard_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_hard_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_ai_hard_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_delay_item_drop(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_delay_item_drop_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_delay_item_drop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_delay_item_drop_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.delay_item_drop(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pet_delay_item_drop_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_delay_item_drop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_delay_item_drop_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_lootitem_drop(struct pet_data *pd, struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_lootitem_drop_pre ) {
+		int (*preHookFunc) (struct pet_data *pd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_lootitem_drop_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_lootitem_drop_pre[hIndex].func;
+			retVal___ = preHookFunc(pd, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.lootitem_drop(pd, sd);
+	}
+	if( HPMHooks.count.HP_pet_lootitem_drop_post ) {
+		int (*postHookFunc) (int retVal___, struct pet_data *pd, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_lootitem_drop_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_lootitem_drop_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, pd, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_skill_bonus_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_skill_bonus_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_skill_bonus_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_skill_bonus_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.skill_bonus_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pet_skill_bonus_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_skill_bonus_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_skill_bonus_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_recovery_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_recovery_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recovery_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_recovery_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.recovery_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pet_recovery_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recovery_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_recovery_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_heal_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_heal_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_heal_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_heal_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.heal_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pet_heal_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_heal_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_heal_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_skill_support_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_skill_support_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_skill_support_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_skill_support_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.skill_support_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_pet_skill_support_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_skill_support_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_skill_support_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_pet_read_db(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_pet_read_db_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_read_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_pet_read_db_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.pet.read_db();
+	}
+	if( HPMHooks.count.HP_pet_read_db_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_read_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_pet_read_db_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+/* quest */
+void HP_quest_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_quest_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.quest.init();
+	}
+	if( HPMHooks.count.HP_quest_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_quest_reload(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_quest_reload_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_reload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_reload_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.quest.reload();
+	}
+	if( HPMHooks.count.HP_quest_reload_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_reload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_reload_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_quest_search_db(int quest_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_search_db_pre ) {
+		int (*preHookFunc) (int *quest_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_search_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_search_db_pre[hIndex].func;
+			retVal___ = preHookFunc(&quest_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.quest.search_db(quest_id);
+	}
+	if( HPMHooks.count.HP_quest_search_db_post ) {
+		int (*postHookFunc) (int retVal___, int *quest_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_search_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_search_db_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &quest_id);
+		}
+	}
+	return retVal___;
+}
+int HP_quest_pc_login(TBL_PC *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_pc_login_pre ) {
+		int (*preHookFunc) (TBL_PC *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_pc_login_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_pc_login_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.quest.pc_login(sd);
+	}
+	if( HPMHooks.count.HP_quest_pc_login_post ) {
+		int (*postHookFunc) (int retVal___, TBL_PC *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_pc_login_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_pc_login_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_quest_add(TBL_PC *sd, int quest_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_add_pre ) {
+		int (*preHookFunc) (TBL_PC *sd, int *quest_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_add_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &quest_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.quest.add(sd, quest_id);
+	}
+	if( HPMHooks.count.HP_quest_add_post ) {
+		int (*postHookFunc) (int retVal___, TBL_PC *sd, int *quest_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_add_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &quest_id);
+		}
+	}
+	return retVal___;
+}
+int HP_quest_change(TBL_PC *sd, int qid1, int qid2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_change_pre ) {
+		int (*preHookFunc) (TBL_PC *sd, int *qid1, int *qid2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_change_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_change_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &qid1, &qid2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.quest.change(sd, qid1, qid2);
+	}
+	if( HPMHooks.count.HP_quest_change_post ) {
+		int (*postHookFunc) (int retVal___, TBL_PC *sd, int *qid1, int *qid2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_change_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_change_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &qid1, &qid2);
+		}
+	}
+	return retVal___;
+}
+int HP_quest_delete(TBL_PC *sd, int quest_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_delete_pre ) {
+		int (*preHookFunc) (TBL_PC *sd, int *quest_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_delete_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &quest_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.quest.delete(sd, quest_id);
+	}
+	if( HPMHooks.count.HP_quest_delete_post ) {
+		int (*postHookFunc) (int retVal___, TBL_PC *sd, int *quest_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_delete_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &quest_id);
+		}
+	}
+	return retVal___;
+}
+int HP_quest_update_objective_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_update_objective_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_quest_update_objective_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.quest.update_objective_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_quest_update_objective_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_quest_update_objective_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_quest_update_objective(TBL_PC *sd, int mob_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_quest_update_objective_pre ) {
+		void (*preHookFunc) (TBL_PC *sd, int *mob_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_update_objective_pre[hIndex].func;
+			preHookFunc(sd, &mob_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.quest.update_objective(sd, mob_id);
+	}
+	if( HPMHooks.count.HP_quest_update_objective_post ) {
+		void (*postHookFunc) (TBL_PC *sd, int *mob_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_update_objective_post[hIndex].func;
+			postHookFunc(sd, &mob_id);
+		}
+	}
+	return;
+}
+int HP_quest_update_status(TBL_PC *sd, int quest_id, quest_state qs) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_update_status_pre ) {
+		int (*preHookFunc) (TBL_PC *sd, int *quest_id, quest_state *qs);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_status_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_update_status_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &quest_id, &qs);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.quest.update_status(sd, quest_id, qs);
+	}
+	if( HPMHooks.count.HP_quest_update_status_post ) {
+		int (*postHookFunc) (int retVal___, TBL_PC *sd, int *quest_id, quest_state *qs);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_status_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_update_status_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &quest_id, &qs);
+		}
+	}
+	return retVal___;
+}
+int HP_quest_check(TBL_PC *sd, int quest_id, quest_check_type type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_check_pre ) {
+		int (*preHookFunc) (TBL_PC *sd, int *quest_id, quest_check_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_check_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &quest_id, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.quest.check(sd, quest_id, type);
+	}
+	if( HPMHooks.count.HP_quest_check_post ) {
+		int (*postHookFunc) (int retVal___, TBL_PC *sd, int *quest_id, quest_check_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &quest_id, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_quest_read_db(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_quest_read_db_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_read_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_quest_read_db_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.quest.read_db();
+	}
+	if( HPMHooks.count.HP_quest_read_db_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_read_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_quest_read_db_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+/* script */
+void HP_script_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.init();
+	}
+	if( HPMHooks.count.HP_script_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_script_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.final();
+	}
+	if( HPMHooks.count.HP_script_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_script_reload(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_reload_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_reload_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.reload();
+	}
+	if( HPMHooks.count.HP_script_reload_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_reload_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+struct script_code* HP_script_parse(const char *src, const char *file, int line, int options) {
+	int hIndex = 0;
+	struct script_code* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_pre ) {
+		struct script_code* (*preHookFunc) (const char *src, const char *file, int *line, int *options);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_pre[hIndex].func;
+			retVal___ = preHookFunc(src, file, &line, &options);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse(src, file, line, options);
+	}
+	if( HPMHooks.count.HP_script_parse_post ) {
+		struct script_code* (*postHookFunc) (struct script_code* retVal___, const char *src, const char *file, int *line, int *options);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, file, &line, &options);
+		}
+	}
+	return retVal___;
+}
+void HP_script_parse_builtin(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_parse_builtin_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_builtin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_builtin_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.parse_builtin();
+	}
+	if( HPMHooks.count.HP_script_parse_builtin_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_builtin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_builtin_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+const char* HP_script_parse_subexpr(const char *p, int limit) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_subexpr_pre ) {
+		const char* (*preHookFunc) (const char *p, int *limit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_subexpr_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_subexpr_pre[hIndex].func;
+			retVal___ = preHookFunc(p, &limit);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_subexpr(p, limit);
+	}
+	if( HPMHooks.count.HP_script_parse_subexpr_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p, int *limit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_subexpr_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_subexpr_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p, &limit);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_skip_space(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_skip_space_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_skip_space_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_skip_space_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.skip_space(p);
+	}
+	if( HPMHooks.count.HP_script_skip_space_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_skip_space_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_skip_space_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+void HP_script_error(const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_error_pre ) {
+		void (*preHookFunc) (const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_error_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_error_pre[hIndex].func;
+			preHookFunc(src, file, &start_line, error_msg, error_pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.error(src, file, start_line, error_msg, error_pos);
+	}
+	if( HPMHooks.count.HP_script_error_post ) {
+		void (*postHookFunc) (const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_error_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_error_post[hIndex].func;
+			postHookFunc(src, file, &start_line, error_msg, error_pos);
+		}
+	}
+	return;
+}
+void HP_script_warning(const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_warning_pre ) {
+		void (*preHookFunc) (const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_warning_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_warning_pre[hIndex].func;
+			preHookFunc(src, file, &start_line, error_msg, error_pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.warning(src, file, start_line, error_msg, error_pos);
+	}
+	if( HPMHooks.count.HP_script_warning_post ) {
+		void (*postHookFunc) (const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_warning_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_warning_post[hIndex].func;
+			postHookFunc(src, file, &start_line, error_msg, error_pos);
+		}
+	}
+	return;
+}
+bool HP_script_addScript(char *name, char *args, bool ( *func ) (struct script_state *st)) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_script_addScript_pre ) {
+		bool (*preHookFunc) (char *name, char *args, bool ( *func ) (struct script_state *st));
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addScript_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_addScript_pre[hIndex].func;
+			retVal___ = preHookFunc(name, args, func);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.addScript(name, args, func);
+	}
+	if( HPMHooks.count.HP_script_addScript_post ) {
+		bool (*postHookFunc) (bool retVal___, char *name, char *args, bool ( *func ) (struct script_state *st));
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addScript_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_addScript_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, args, func);
+		}
+	}
+	return retVal___;
+}
+int HP_script_conv_num(struct script_state *st, struct script_data *data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_conv_num_pre ) {
+		int (*preHookFunc) (struct script_state *st, struct script_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_conv_num_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_conv_num_pre[hIndex].func;
+			retVal___ = preHookFunc(st, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.conv_num(st, data);
+	}
+	if( HPMHooks.count.HP_script_conv_num_post ) {
+		int (*postHookFunc) (int retVal___, struct script_state *st, struct script_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_conv_num_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_conv_num_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st, data);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_conv_str(struct script_state *st, struct script_data *data) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_conv_str_pre ) {
+		const char* (*preHookFunc) (struct script_state *st, struct script_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_conv_str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_conv_str_pre[hIndex].func;
+			retVal___ = preHookFunc(st, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.conv_str(st, data);
+	}
+	if( HPMHooks.count.HP_script_conv_str_post ) {
+		const char* (*postHookFunc) (const char* retVal___, struct script_state *st, struct script_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_conv_str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_conv_str_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st, data);
+		}
+	}
+	return retVal___;
+}
+TBL_PC* HP_script_rid2sd(struct script_state *st) {
+	int hIndex = 0;
+	TBL_PC* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_rid2sd_pre ) {
+		TBL_PC* (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_rid2sd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_rid2sd_pre[hIndex].func;
+			retVal___ = preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.rid2sd(st);
+	}
+	if( HPMHooks.count.HP_script_rid2sd_post ) {
+		TBL_PC* (*postHookFunc) (TBL_PC* retVal___, struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_rid2sd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_rid2sd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st);
+		}
+	}
+	return retVal___;
+}
+void HP_script_detach_rid(struct script_state *st) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_detach_rid_pre ) {
+		void (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_rid_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_detach_rid_pre[hIndex].func;
+			preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.detach_rid(st);
+	}
+	if( HPMHooks.count.HP_script_detach_rid_post ) {
+		void (*postHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_rid_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_detach_rid_post[hIndex].func;
+			postHookFunc(st);
+		}
+	}
+	return;
+}
+struct script_data* HP_script_push_val(struct script_stack *stack, enum c_op type, int val, struct DBMap **ref) {
+	int hIndex = 0;
+	struct script_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_push_val_pre ) {
+		struct script_data* (*preHookFunc) (struct script_stack *stack, enum c_op *type, int *val, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_val_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_push_val_pre[hIndex].func;
+			retVal___ = preHookFunc(stack, &type, &val, ref);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.push_val(stack, type, val, ref);
+	}
+	if( HPMHooks.count.HP_script_push_val_post ) {
+		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, enum c_op *type, int *val, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_val_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_push_val_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, stack, &type, &val, ref);
+		}
+	}
+	return retVal___;
+}
+void HP_script_get_val(struct script_state *st, struct script_data *data) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_get_val_pre ) {
+		void (*preHookFunc) (struct script_state *st, struct script_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_get_val_pre[hIndex].func;
+			preHookFunc(st, data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.get_val(st, data);
+	}
+	if( HPMHooks.count.HP_script_get_val_post ) {
+		void (*postHookFunc) (struct script_state *st, struct script_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_get_val_post[hIndex].func;
+			postHookFunc(st, data);
+		}
+	}
+	return;
+}
+void* HP_script_get_val2(struct script_state *st, int uid, struct DBMap **ref) {
+	int hIndex = 0;
+	void* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_get_val2_pre ) {
+		void* (*preHookFunc) (struct script_state *st, int *uid, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_get_val2_pre[hIndex].func;
+			retVal___ = preHookFunc(st, &uid, ref);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.get_val2(st, uid, ref);
+	}
+	if( HPMHooks.count.HP_script_get_val2_post ) {
+		void* (*postHookFunc) (void* retVal___, struct script_state *st, int *uid, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_get_val2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st, &uid, ref);
+		}
+	}
+	return retVal___;
+}
+struct script_data* HP_script_push_str(struct script_stack *stack, enum c_op type, char *str) {
+	int hIndex = 0;
+	struct script_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_push_str_pre ) {
+		struct script_data* (*preHookFunc) (struct script_stack *stack, enum c_op *type, char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_push_str_pre[hIndex].func;
+			retVal___ = preHookFunc(stack, &type, str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.push_str(stack, type, str);
+	}
+	if( HPMHooks.count.HP_script_push_str_post ) {
+		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, enum c_op *type, char *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_push_str_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, stack, &type, str);
+		}
+	}
+	return retVal___;
+}
+struct script_data* HP_script_push_copy(struct script_stack *stack, int pos) {
+	int hIndex = 0;
+	struct script_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_push_copy_pre ) {
+		struct script_data* (*preHookFunc) (struct script_stack *stack, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_copy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_push_copy_pre[hIndex].func;
+			retVal___ = preHookFunc(stack, &pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.push_copy(stack, pos);
+	}
+	if( HPMHooks.count.HP_script_push_copy_post ) {
+		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_copy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_push_copy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, stack, &pos);
+		}
+	}
+	return retVal___;
+}
+void HP_script_pop_stack(struct script_state *st, int start, int end) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_pop_stack_pre ) {
+		void (*preHookFunc) (struct script_state *st, int *start, int *end);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_pop_stack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_pop_stack_pre[hIndex].func;
+			preHookFunc(st, &start, &end);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.pop_stack(st, start, end);
+	}
+	if( HPMHooks.count.HP_script_pop_stack_post ) {
+		void (*postHookFunc) (struct script_state *st, int *start, int *end);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_pop_stack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_pop_stack_post[hIndex].func;
+			postHookFunc(st, &start, &end);
+		}
+	}
+	return;
+}
+void HP_script_set_constant(const char *name, int value, bool isparameter) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_set_constant_pre ) {
+		void (*preHookFunc) (const char *name, int *value, bool *isparameter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_set_constant_pre[hIndex].func;
+			preHookFunc(name, &value, &isparameter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.set_constant(name, value, isparameter);
+	}
+	if( HPMHooks.count.HP_script_set_constant_post ) {
+		void (*postHookFunc) (const char *name, int *value, bool *isparameter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_set_constant_post[hIndex].func;
+			postHookFunc(name, &value, &isparameter);
+		}
+	}
+	return;
+}
+void HP_script_set_constant2(const char *name, int value, bool isparameter) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_set_constant2_pre ) {
+		void (*preHookFunc) (const char *name, int *value, bool *isparameter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_set_constant2_pre[hIndex].func;
+			preHookFunc(name, &value, &isparameter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.set_constant2(name, value, isparameter);
+	}
+	if( HPMHooks.count.HP_script_set_constant2_post ) {
+		void (*postHookFunc) (const char *name, int *value, bool *isparameter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_set_constant2_post[hIndex].func;
+			postHookFunc(name, &value, &isparameter);
+		}
+	}
+	return;
+}
+void HP_script_set_constant_force(const char *name, int value, bool isparameter) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_set_constant_force_pre ) {
+		void (*preHookFunc) (const char *name, int *value, bool *isparameter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant_force_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_set_constant_force_pre[hIndex].func;
+			preHookFunc(name, &value, &isparameter);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.set_constant_force(name, value, isparameter);
+	}
+	if( HPMHooks.count.HP_script_set_constant_force_post ) {
+		void (*postHookFunc) (const char *name, int *value, bool *isparameter);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant_force_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_set_constant_force_post[hIndex].func;
+			postHookFunc(name, &value, &isparameter);
+		}
+	}
+	return;
+}
+bool HP_script_get_constant(const char *name, int *value) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_script_get_constant_pre ) {
+		bool (*preHookFunc) (const char *name, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_constant_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_get_constant_pre[hIndex].func;
+			retVal___ = preHookFunc(name, value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.get_constant(name, value);
+	}
+	if( HPMHooks.count.HP_script_get_constant_post ) {
+		bool (*postHookFunc) (bool retVal___, const char *name, int *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_constant_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_get_constant_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name, value);
+		}
+	}
+	return retVal___;
+}
+void HP_script_label_add(int key, int pos) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_label_add_pre ) {
+		void (*preHookFunc) (int *key, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_label_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_label_add_pre[hIndex].func;
+			preHookFunc(&key, &pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.label_add(key, pos);
+	}
+	if( HPMHooks.count.HP_script_label_add_post ) {
+		void (*postHookFunc) (int *key, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_label_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_label_add_post[hIndex].func;
+			postHookFunc(&key, &pos);
+		}
+	}
+	return;
+}
+void HP_script_run(struct script_code *rootscript, int pos, int rid, int oid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_run_pre ) {
+		void (*preHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_run_pre[hIndex].func;
+			preHookFunc(rootscript, &pos, &rid, &oid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.run(rootscript, pos, rid, oid);
+	}
+	if( HPMHooks.count.HP_script_run_post ) {
+		void (*postHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_run_post[hIndex].func;
+			postHookFunc(rootscript, &pos, &rid, &oid);
+		}
+	}
+	return;
+}
+void HP_script_run_main(struct script_state *st) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_run_main_pre ) {
+		void (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_main_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_run_main_pre[hIndex].func;
+			preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.run_main(st);
+	}
+	if( HPMHooks.count.HP_script_run_main_post ) {
+		void (*postHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_main_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_run_main_post[hIndex].func;
+			postHookFunc(st);
+		}
+	}
+	return;
+}
+int HP_script_run_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_run_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_run_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.run_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_script_run_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_run_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_script_set_var(struct map_session_data *sd, char *name, void *val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_set_var_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, char *name, void *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_var_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_set_var_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, name, val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.set_var(sd, name, val);
+	}
+	if( HPMHooks.count.HP_script_set_var_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, char *name, void *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_var_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_set_var_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, name, val);
+		}
+	}
+	return retVal___;
+}
+void HP_script_stop_instances(struct script_code *code) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_stop_instances_pre ) {
+		void (*preHookFunc) (struct script_code *code);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stop_instances_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_stop_instances_pre[hIndex].func;
+			preHookFunc(code);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.stop_instances(code);
+	}
+	if( HPMHooks.count.HP_script_stop_instances_post ) {
+		void (*postHookFunc) (struct script_code *code);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stop_instances_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_stop_instances_post[hIndex].func;
+			postHookFunc(code);
+		}
+	}
+	return;
+}
+void HP_script_free_code(struct script_code *code) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_free_code_pre ) {
+		void (*preHookFunc) (struct script_code *code);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_code_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_free_code_pre[hIndex].func;
+			preHookFunc(code);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.free_code(code);
+	}
+	if( HPMHooks.count.HP_script_free_code_post ) {
+		void (*postHookFunc) (struct script_code *code);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_code_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_free_code_post[hIndex].func;
+			postHookFunc(code);
+		}
+	}
+	return;
+}
+void HP_script_free_vars(struct DBMap *var_storage) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_free_vars_pre ) {
+		void (*preHookFunc) (struct DBMap *var_storage);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_vars_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_free_vars_pre[hIndex].func;
+			preHookFunc(var_storage);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.free_vars(var_storage);
+	}
+	if( HPMHooks.count.HP_script_free_vars_post ) {
+		void (*postHookFunc) (struct DBMap *var_storage);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_vars_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_free_vars_post[hIndex].func;
+			postHookFunc(var_storage);
+		}
+	}
+	return;
+}
+struct script_state* HP_script_alloc_state(struct script_code *rootscript, int pos, int rid, int oid) {
+	int hIndex = 0;
+	struct script_state* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_alloc_state_pre ) {
+		struct script_state* (*preHookFunc) (struct script_code *rootscript, int *pos, int *rid, int *oid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_alloc_state_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_alloc_state_pre[hIndex].func;
+			retVal___ = preHookFunc(rootscript, &pos, &rid, &oid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.alloc_state(rootscript, pos, rid, oid);
+	}
+	if( HPMHooks.count.HP_script_alloc_state_post ) {
+		struct script_state* (*postHookFunc) (struct script_state* retVal___, struct script_code *rootscript, int *pos, int *rid, int *oid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_alloc_state_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_alloc_state_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, rootscript, &pos, &rid, &oid);
+		}
+	}
+	return retVal___;
+}
+void HP_script_free_state(struct script_state *st) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_free_state_pre ) {
+		void (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_state_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_free_state_pre[hIndex].func;
+			preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.free_state(st);
+	}
+	if( HPMHooks.count.HP_script_free_state_post ) {
+		void (*postHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_state_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_free_state_post[hIndex].func;
+			postHookFunc(st);
+		}
+	}
+	return;
+}
+void HP_script_run_autobonus(const char *autobonus, int id, int pos) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_run_autobonus_pre ) {
+		void (*preHookFunc) (const char *autobonus, int *id, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_autobonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_run_autobonus_pre[hIndex].func;
+			preHookFunc(autobonus, &id, &pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.run_autobonus(autobonus, id, pos);
+	}
+	if( HPMHooks.count.HP_script_run_autobonus_post ) {
+		void (*postHookFunc) (const char *autobonus, int *id, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_autobonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_run_autobonus_post[hIndex].func;
+			postHookFunc(autobonus, &id, &pos);
+		}
+	}
+	return;
+}
+void HP_script_cleararray_pc(struct map_session_data *sd, const char *varname, void *value) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_cleararray_pc_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *varname, void *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_cleararray_pc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_cleararray_pc_pre[hIndex].func;
+			preHookFunc(sd, varname, value);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.cleararray_pc(sd, varname, value);
+	}
+	if( HPMHooks.count.HP_script_cleararray_pc_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *varname, void *value);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_cleararray_pc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_cleararray_pc_post[hIndex].func;
+			postHookFunc(sd, varname, value);
+		}
+	}
+	return;
+}
+void HP_script_setarray_pc(struct map_session_data *sd, const char *varname, uint8 idx, void *value, int *refcache) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_setarray_pc_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *varname, uint8 *idx, void *value, int *refcache);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setarray_pc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_setarray_pc_pre[hIndex].func;
+			preHookFunc(sd, varname, &idx, value, refcache);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.setarray_pc(sd, varname, idx, value, refcache);
+	}
+	if( HPMHooks.count.HP_script_setarray_pc_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *varname, uint8 *idx, void *value, int *refcache);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setarray_pc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_setarray_pc_post[hIndex].func;
+			postHookFunc(sd, varname, &idx, value, refcache);
+		}
+	}
+	return;
+}
+int HP_script_config_read(char *cfgName) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_config_read_pre ) {
+		int (*preHookFunc) (char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_config_read_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_config_read_pre[hIndex].func;
+			retVal___ = preHookFunc(cfgName);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.config_read(cfgName);
+	}
+	if( HPMHooks.count.HP_script_config_read_post ) {
+		int (*postHookFunc) (int retVal___, char *cfgName);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_config_read_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_config_read_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, cfgName);
+		}
+	}
+	return retVal___;
+}
+int HP_script_add_str(const char *p) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_add_str_pre ) {
+		int (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_add_str_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.add_str(p);
+	}
+	if( HPMHooks.count.HP_script_add_str_post ) {
+		int (*postHookFunc) (int retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_add_str_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_get_str(int id) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_get_str_pre ) {
+		const char* (*preHookFunc) (int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_get_str_pre[hIndex].func;
+			retVal___ = preHookFunc(&id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.get_str(id);
+	}
+	if( HPMHooks.count.HP_script_get_str_post ) {
+		const char* (*postHookFunc) (const char* retVal___, int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_get_str_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &id);
+		}
+	}
+	return retVal___;
+}
+int HP_script_search_str(const char *p) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_search_str_pre ) {
+		int (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_search_str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_search_str_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.search_str(p);
+	}
+	if( HPMHooks.count.HP_script_search_str_post ) {
+		int (*postHookFunc) (int retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_search_str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_search_str_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+void HP_script_setd_sub(struct script_state *st, struct map_session_data *sd, const char *varname, int elem, void *value, struct DBMap **ref) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_setd_sub_pre ) {
+		void (*preHookFunc) (struct script_state *st, struct map_session_data *sd, const char *varname, int *elem, void *value, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setd_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_setd_sub_pre[hIndex].func;
+			preHookFunc(st, sd, varname, &elem, value, ref);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.setd_sub(st, sd, varname, elem, value, ref);
+	}
+	if( HPMHooks.count.HP_script_setd_sub_post ) {
+		void (*postHookFunc) (struct script_state *st, struct map_session_data *sd, const char *varname, int *elem, void *value, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setd_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_setd_sub_post[hIndex].func;
+			postHookFunc(st, sd, varname, &elem, value, ref);
+		}
+	}
+	return;
+}
+void HP_script_attach_state(struct script_state *st) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_attach_state_pre ) {
+		void (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_attach_state_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_attach_state_pre[hIndex].func;
+			preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.attach_state(st);
+	}
+	if( HPMHooks.count.HP_script_attach_state_post ) {
+		void (*postHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_attach_state_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_attach_state_post[hIndex].func;
+			postHookFunc(st);
+		}
+	}
+	return;
+}
+struct hQueue* HP_script_queue(int idx) {
+	int hIndex = 0;
+	struct hQueue* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_queue_pre ) {
+		struct hQueue* (*preHookFunc) (int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_queue_pre[hIndex].func;
+			retVal___ = preHookFunc(&idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.queue(idx);
+	}
+	if( HPMHooks.count.HP_script_queue_post ) {
+		struct hQueue* (*postHookFunc) (struct hQueue* retVal___, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_queue_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &idx);
+		}
+	}
+	return retVal___;
+}
+bool HP_script_queue_add(int idx, int var) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_script_queue_add_pre ) {
+		bool (*preHookFunc) (int *idx, int *var);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_queue_add_pre[hIndex].func;
+			retVal___ = preHookFunc(&idx, &var);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.queue_add(idx, var);
+	}
+	if( HPMHooks.count.HP_script_queue_add_post ) {
+		bool (*postHookFunc) (bool retVal___, int *idx, int *var);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_queue_add_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &idx, &var);
+		}
+	}
+	return retVal___;
+}
+bool HP_script_queue_del(int idx) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_script_queue_del_pre ) {
+		bool (*preHookFunc) (int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_del_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_queue_del_pre[hIndex].func;
+			retVal___ = preHookFunc(&idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.queue_del(idx);
+	}
+	if( HPMHooks.count.HP_script_queue_del_post ) {
+		bool (*postHookFunc) (bool retVal___, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_del_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_queue_del_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &idx);
+		}
+	}
+	return retVal___;
+}
+bool HP_script_queue_remove(int idx, int var) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_script_queue_remove_pre ) {
+		bool (*preHookFunc) (int *idx, int *var);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_queue_remove_pre[hIndex].func;
+			retVal___ = preHookFunc(&idx, &var);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.queue_remove(idx, var);
+	}
+	if( HPMHooks.count.HP_script_queue_remove_post ) {
+		bool (*postHookFunc) (bool retVal___, int *idx, int *var);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_queue_remove_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &idx, &var);
+		}
+	}
+	return retVal___;
+}
+int HP_script_queue_create(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_queue_create_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_queue_create_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.queue_create();
+	}
+	if( HPMHooks.count.HP_script_queue_create_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_queue_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_script_queue_clear(int idx) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_queue_clear_pre ) {
+		void (*preHookFunc) (int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_queue_clear_pre[hIndex].func;
+			preHookFunc(&idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.queue_clear(idx);
+	}
+	if( HPMHooks.count.HP_script_queue_clear_post ) {
+		void (*postHookFunc) (int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_queue_clear_post[hIndex].func;
+			postHookFunc(&idx);
+		}
+	}
+	return;
+}
+const char* HP_script_parse_curly_close(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_curly_close_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_curly_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_curly_close_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_curly_close(p);
+	}
+	if( HPMHooks.count.HP_script_parse_curly_close_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_curly_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_curly_close_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_parse_syntax_close(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_syntax_close_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_syntax_close_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_syntax_close(p);
+	}
+	if( HPMHooks.count.HP_script_parse_syntax_close_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_syntax_close_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_parse_syntax_close_sub(const char *p, int *flag) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_syntax_close_sub_pre ) {
+		const char* (*preHookFunc) (const char *p, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_close_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_syntax_close_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(p, flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_syntax_close_sub(p, flag);
+	}
+	if( HPMHooks.count.HP_script_parse_syntax_close_sub_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_close_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_syntax_close_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p, flag);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_parse_syntax(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_syntax_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_syntax_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_syntax(p);
+	}
+	if( HPMHooks.count.HP_script_parse_syntax_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_syntax_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+c_op HP_script_get_com(unsigned char *scriptbuf, int *pos) {
+	int hIndex = 0;
+	c_op retVal___;
+	memset(&retVal___, '\0', sizeof(c_op));
+	if( HPMHooks.count.HP_script_get_com_pre ) {
+		c_op (*preHookFunc) (unsigned char *scriptbuf, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_com_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_get_com_pre[hIndex].func;
+			retVal___ = preHookFunc(scriptbuf, pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.get_com(scriptbuf, pos);
+	}
+	if( HPMHooks.count.HP_script_get_com_post ) {
+		c_op (*postHookFunc) (c_op retVal___, unsigned char *scriptbuf, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_com_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_get_com_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, scriptbuf, pos);
+		}
+	}
+	return retVal___;
+}
+int HP_script_get_num(unsigned char *scriptbuf, int *pos) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_get_num_pre ) {
+		int (*preHookFunc) (unsigned char *scriptbuf, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_num_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_get_num_pre[hIndex].func;
+			retVal___ = preHookFunc(scriptbuf, pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.get_num(scriptbuf, pos);
+	}
+	if( HPMHooks.count.HP_script_get_num_post ) {
+		int (*postHookFunc) (int retVal___, unsigned char *scriptbuf, int *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_num_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_get_num_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, scriptbuf, pos);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_op2name(int op) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_op2name_pre ) {
+		const char* (*preHookFunc) (int *op);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op2name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_op2name_pre[hIndex].func;
+			retVal___ = preHookFunc(&op);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.op2name(op);
+	}
+	if( HPMHooks.count.HP_script_op2name_post ) {
+		const char* (*postHookFunc) (const char* retVal___, int *op);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op2name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_op2name_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &op);
+		}
+	}
+	return retVal___;
+}
+void HP_script_reportsrc(struct script_state *st) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_reportsrc_pre ) {
+		void (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportsrc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_reportsrc_pre[hIndex].func;
+			preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.reportsrc(st);
+	}
+	if( HPMHooks.count.HP_script_reportsrc_post ) {
+		void (*postHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportsrc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_reportsrc_post[hIndex].func;
+			postHookFunc(st);
+		}
+	}
+	return;
+}
+void HP_script_reportdata(struct script_data *data) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_reportdata_pre ) {
+		void (*preHookFunc) (struct script_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_reportdata_pre[hIndex].func;
+			preHookFunc(data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.reportdata(data);
+	}
+	if( HPMHooks.count.HP_script_reportdata_post ) {
+		void (*postHookFunc) (struct script_data *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_reportdata_post[hIndex].func;
+			postHookFunc(data);
+		}
+	}
+	return;
+}
+void HP_script_reportfunc(struct script_state *st) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_reportfunc_pre ) {
+		void (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportfunc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_reportfunc_pre[hIndex].func;
+			preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.reportfunc(st);
+	}
+	if( HPMHooks.count.HP_script_reportfunc_post ) {
+		void (*postHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportfunc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_reportfunc_post[hIndex].func;
+			postHookFunc(st);
+		}
+	}
+	return;
+}
+void HP_script_disp_error_message2(const char *mes, const char *pos, int report) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_disp_error_message2_pre ) {
+		void (*preHookFunc) (const char *mes, const char *pos, int *report);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_disp_error_message2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_disp_error_message2_pre[hIndex].func;
+			preHookFunc(mes, pos, &report);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.disp_error_message2(mes, pos, report);
+	}
+	if( HPMHooks.count.HP_script_disp_error_message2_post ) {
+		void (*postHookFunc) (const char *mes, const char *pos, int *report);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_disp_error_message2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_disp_error_message2_post[hIndex].func;
+			postHookFunc(mes, pos, &report);
+		}
+	}
+	return;
+}
+void HP_script_disp_warning_message(const char *mes, const char *pos) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_disp_warning_message_pre ) {
+		void (*preHookFunc) (const char *mes, const char *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_disp_warning_message_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_disp_warning_message_pre[hIndex].func;
+			preHookFunc(mes, pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.disp_warning_message(mes, pos);
+	}
+	if( HPMHooks.count.HP_script_disp_warning_message_post ) {
+		void (*postHookFunc) (const char *mes, const char *pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_disp_warning_message_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_disp_warning_message_post[hIndex].func;
+			postHookFunc(mes, pos);
+		}
+	}
+	return;
+}
+void HP_script_check_event(struct script_state *st, const char *evt) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_check_event_pre ) {
+		void (*preHookFunc) (struct script_state *st, const char *evt);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_event_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_check_event_pre[hIndex].func;
+			preHookFunc(st, evt);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.check_event(st, evt);
+	}
+	if( HPMHooks.count.HP_script_check_event_post ) {
+		void (*postHookFunc) (struct script_state *st, const char *evt);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_event_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_check_event_post[hIndex].func;
+			postHookFunc(st, evt);
+		}
+	}
+	return;
+}
+unsigned int HP_script_calc_hash(const char *p) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_script_calc_hash_pre ) {
+		unsigned int (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_calc_hash_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_calc_hash_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.calc_hash(p);
+	}
+	if( HPMHooks.count.HP_script_calc_hash_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_calc_hash_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_calc_hash_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+void HP_script_addb(int a) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_addb_pre ) {
+		void (*preHookFunc) (int *a);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_addb_pre[hIndex].func;
+			preHookFunc(&a);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.addb(a);
+	}
+	if( HPMHooks.count.HP_script_addb_post ) {
+		void (*postHookFunc) (int *a);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_addb_post[hIndex].func;
+			postHookFunc(&a);
+		}
+	}
+	return;
+}
+void HP_script_addc(int a) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_addc_pre ) {
+		void (*preHookFunc) (int *a);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_addc_pre[hIndex].func;
+			preHookFunc(&a);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.addc(a);
+	}
+	if( HPMHooks.count.HP_script_addc_post ) {
+		void (*postHookFunc) (int *a);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_addc_post[hIndex].func;
+			postHookFunc(&a);
+		}
+	}
+	return;
+}
+void HP_script_addi(int a) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_addi_pre ) {
+		void (*preHookFunc) (int *a);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addi_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_addi_pre[hIndex].func;
+			preHookFunc(&a);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.addi(a);
+	}
+	if( HPMHooks.count.HP_script_addi_post ) {
+		void (*postHookFunc) (int *a);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addi_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_addi_post[hIndex].func;
+			postHookFunc(&a);
+		}
+	}
+	return;
+}
+void HP_script_addl(int l) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_addl_pre ) {
+		void (*preHookFunc) (int *l);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addl_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_addl_pre[hIndex].func;
+			preHookFunc(&l);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.addl(l);
+	}
+	if( HPMHooks.count.HP_script_addl_post ) {
+		void (*postHookFunc) (int *l);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addl_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_addl_post[hIndex].func;
+			postHookFunc(&l);
+		}
+	}
+	return;
+}
+void HP_script_set_label(int l, int pos, const char *script_pos) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_set_label_pre ) {
+		void (*preHookFunc) (int *l, int *pos, const char *script_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_label_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_set_label_pre[hIndex].func;
+			preHookFunc(&l, &pos, script_pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.set_label(l, pos, script_pos);
+	}
+	if( HPMHooks.count.HP_script_set_label_post ) {
+		void (*postHookFunc) (int *l, int *pos, const char *script_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_label_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_set_label_post[hIndex].func;
+			postHookFunc(&l, &pos, script_pos);
+		}
+	}
+	return;
+}
+const char* HP_script_skip_word(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_skip_word_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_skip_word_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_skip_word_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.skip_word(p);
+	}
+	if( HPMHooks.count.HP_script_skip_word_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_skip_word_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_skip_word_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+int HP_script_add_word(const char *p) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_add_word_pre ) {
+		int (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_word_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_add_word_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.add_word(p);
+	}
+	if( HPMHooks.count.HP_script_add_word_post ) {
+		int (*postHookFunc) (int retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_word_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_add_word_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_parse_callfunc(const char *p, int require_paren, int is_custom) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_callfunc_pre ) {
+		const char* (*preHookFunc) (const char *p, int *require_paren, int *is_custom);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_callfunc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_callfunc_pre[hIndex].func;
+			retVal___ = preHookFunc(p, &require_paren, &is_custom);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_callfunc(p, require_paren, is_custom);
+	}
+	if( HPMHooks.count.HP_script_parse_callfunc_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p, int *require_paren, int *is_custom);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_callfunc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_callfunc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p, &require_paren, &is_custom);
+		}
+	}
+	return retVal___;
+}
+void HP_script_parse_nextline(bool first, const char *p) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_parse_nextline_pre ) {
+		void (*preHookFunc) (bool *first, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_nextline_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_nextline_pre[hIndex].func;
+			preHookFunc(&first, p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.parse_nextline(first, p);
+	}
+	if( HPMHooks.count.HP_script_parse_nextline_post ) {
+		void (*postHookFunc) (bool *first, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_nextline_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_nextline_post[hIndex].func;
+			postHookFunc(&first, p);
+		}
+	}
+	return;
+}
+const char* HP_script_parse_variable(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_variable_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_variable_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_variable_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_variable(p);
+	}
+	if( HPMHooks.count.HP_script_parse_variable_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_variable_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_variable_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_parse_simpleexpr(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_simpleexpr_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_simpleexpr(p);
+	}
+	if( HPMHooks.count.HP_script_parse_simpleexpr_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_parse_expr(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_expr_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_expr_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_expr_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_expr(p);
+	}
+	if( HPMHooks.count.HP_script_parse_expr_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_expr_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_expr_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+const char* HP_script_parse_line(const char *p) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_parse_line_pre ) {
+		const char* (*preHookFunc) (const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_line_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_parse_line_pre[hIndex].func;
+			retVal___ = preHookFunc(p);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.parse_line(p);
+	}
+	if( HPMHooks.count.HP_script_parse_line_post ) {
+		const char* (*postHookFunc) (const char* retVal___, const char *p);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_line_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_parse_line_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, p);
+		}
+	}
+	return retVal___;
+}
+void HP_script_read_constdb(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_read_constdb_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_read_constdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_read_constdb_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.read_constdb();
+	}
+	if( HPMHooks.count.HP_script_read_constdb_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_read_constdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_read_constdb_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+const char* HP_script_print_line(StringBuf *buf, const char *p, const char *mark, int line) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_print_line_pre ) {
+		const char* (*preHookFunc) (StringBuf *buf, const char *p, const char *mark, int *line);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_print_line_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_print_line_pre[hIndex].func;
+			retVal___ = preHookFunc(buf, p, mark, &line);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.print_line(buf, p, mark, line);
+	}
+	if( HPMHooks.count.HP_script_print_line_post ) {
+		const char* (*postHookFunc) (const char* retVal___, StringBuf *buf, const char *p, const char *mark, int *line);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_print_line_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_print_line_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, buf, p, mark, &line);
+		}
+	}
+	return retVal___;
+}
+void HP_script_errorwarning_sub(StringBuf *buf, const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_errorwarning_sub_pre ) {
+		void (*preHookFunc) (StringBuf *buf, const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_errorwarning_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_errorwarning_sub_pre[hIndex].func;
+			preHookFunc(buf, src, file, &start_line, error_msg, error_pos);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.errorwarning_sub(buf, src, file, start_line, error_msg, error_pos);
+	}
+	if( HPMHooks.count.HP_script_errorwarning_sub_post ) {
+		void (*postHookFunc) (StringBuf *buf, const char *src, const char *file, int *start_line, const char *error_msg, const char *error_pos);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_errorwarning_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_errorwarning_sub_post[hIndex].func;
+			postHookFunc(buf, src, file, &start_line, error_msg, error_pos);
+		}
+	}
+	return;
+}
+int HP_script_set_reg(struct script_state *st, TBL_PC *sd, int num, const char *name, const void *value, struct DBMap **ref) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_set_reg_pre ) {
+		int (*preHookFunc) (struct script_state *st, TBL_PC *sd, int *num, const char *name, const void *value, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_set_reg_pre[hIndex].func;
+			retVal___ = preHookFunc(st, sd, &num, name, value, ref);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.set_reg(st, sd, num, name, value, ref);
+	}
+	if( HPMHooks.count.HP_script_set_reg_post ) {
+		int (*postHookFunc) (int retVal___, struct script_state *st, TBL_PC *sd, int *num, const char *name, const void *value, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_set_reg_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st, sd, &num, name, value, ref);
+		}
+	}
+	return retVal___;
+}
+void HP_script_stack_expand(struct script_stack *stack) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_stack_expand_pre ) {
+		void (*preHookFunc) (struct script_stack *stack);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stack_expand_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_stack_expand_pre[hIndex].func;
+			preHookFunc(stack);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.stack_expand(stack);
+	}
+	if( HPMHooks.count.HP_script_stack_expand_post ) {
+		void (*postHookFunc) (struct script_stack *stack);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stack_expand_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_stack_expand_post[hIndex].func;
+			postHookFunc(stack);
+		}
+	}
+	return;
+}
+struct script_data* HP_script_push_retinfo(struct script_stack *stack, struct script_retinfo *ri, DBMap **ref) {
+	int hIndex = 0;
+	struct script_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_script_push_retinfo_pre ) {
+		struct script_data* (*preHookFunc) (struct script_stack *stack, struct script_retinfo *ri, DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_retinfo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_push_retinfo_pre[hIndex].func;
+			retVal___ = preHookFunc(stack, ri, ref);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.push_retinfo(stack, ri, ref);
+	}
+	if( HPMHooks.count.HP_script_push_retinfo_post ) {
+		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, struct script_retinfo *ri, DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_retinfo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_push_retinfo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, stack, ri, ref);
+		}
+	}
+	return retVal___;
+}
+int HP_script_pop_val(struct script_state *st) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_pop_val_pre ) {
+		int (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_pop_val_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_pop_val_pre[hIndex].func;
+			retVal___ = preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.pop_val(st);
+	}
+	if( HPMHooks.count.HP_script_pop_val_post ) {
+		int (*postHookFunc) (int retVal___, struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_pop_val_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_pop_val_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st);
+		}
+	}
+	return retVal___;
+}
+void HP_script_op_3(struct script_state *st, int op) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_op_3_pre ) {
+		void (*preHookFunc) (struct script_state *st, int *op);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_3_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_op_3_pre[hIndex].func;
+			preHookFunc(st, &op);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.op_3(st, op);
+	}
+	if( HPMHooks.count.HP_script_op_3_post ) {
+		void (*postHookFunc) (struct script_state *st, int *op);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_3_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_op_3_post[hIndex].func;
+			postHookFunc(st, &op);
+		}
+	}
+	return;
+}
+void HP_script_op_2str(struct script_state *st, int op, const char *s1, const char *s2) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_op_2str_pre ) {
+		void (*preHookFunc) (struct script_state *st, int *op, const char *s1, const char *s2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_op_2str_pre[hIndex].func;
+			preHookFunc(st, &op, s1, s2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.op_2str(st, op, s1, s2);
+	}
+	if( HPMHooks.count.HP_script_op_2str_post ) {
+		void (*postHookFunc) (struct script_state *st, int *op, const char *s1, const char *s2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_op_2str_post[hIndex].func;
+			postHookFunc(st, &op, s1, s2);
+		}
+	}
+	return;
+}
+void HP_script_op_2num(struct script_state *st, int op, int i1, int i2) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_op_2num_pre ) {
+		void (*preHookFunc) (struct script_state *st, int *op, int *i1, int *i2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2num_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_op_2num_pre[hIndex].func;
+			preHookFunc(st, &op, &i1, &i2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.op_2num(st, op, i1, i2);
+	}
+	if( HPMHooks.count.HP_script_op_2num_post ) {
+		void (*postHookFunc) (struct script_state *st, int *op, int *i1, int *i2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2num_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_op_2num_post[hIndex].func;
+			postHookFunc(st, &op, &i1, &i2);
+		}
+	}
+	return;
+}
+void HP_script_op_2(struct script_state *st, int op) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_op_2_pre ) {
+		void (*preHookFunc) (struct script_state *st, int *op);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_op_2_pre[hIndex].func;
+			preHookFunc(st, &op);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.op_2(st, op);
+	}
+	if( HPMHooks.count.HP_script_op_2_post ) {
+		void (*postHookFunc) (struct script_state *st, int *op);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_op_2_post[hIndex].func;
+			postHookFunc(st, &op);
+		}
+	}
+	return;
+}
+void HP_script_op_1(struct script_state *st, int op) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_op_1_pre ) {
+		void (*preHookFunc) (struct script_state *st, int *op);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_1_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_op_1_pre[hIndex].func;
+			preHookFunc(st, &op);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.op_1(st, op);
+	}
+	if( HPMHooks.count.HP_script_op_1_post ) {
+		void (*postHookFunc) (struct script_state *st, int *op);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_1_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_op_1_post[hIndex].func;
+			postHookFunc(st, &op);
+		}
+	}
+	return;
+}
+void HP_script_check_buildin_argtype(struct script_state *st, int func) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_check_buildin_argtype_pre ) {
+		void (*preHookFunc) (struct script_state *st, int *func);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_buildin_argtype_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_check_buildin_argtype_pre[hIndex].func;
+			preHookFunc(st, &func);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.check_buildin_argtype(st, func);
+	}
+	if( HPMHooks.count.HP_script_check_buildin_argtype_post ) {
+		void (*postHookFunc) (struct script_state *st, int *func);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_buildin_argtype_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_check_buildin_argtype_post[hIndex].func;
+			postHookFunc(st, &func);
+		}
+	}
+	return;
+}
+void HP_script_detach_state(struct script_state *st, bool dequeue_event) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_detach_state_pre ) {
+		void (*preHookFunc) (struct script_state *st, bool *dequeue_event);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_state_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_detach_state_pre[hIndex].func;
+			preHookFunc(st, &dequeue_event);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.detach_state(st, dequeue_event);
+	}
+	if( HPMHooks.count.HP_script_detach_state_post ) {
+		void (*postHookFunc) (struct script_state *st, bool *dequeue_event);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_state_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_detach_state_post[hIndex].func;
+			postHookFunc(st, &dequeue_event);
+		}
+	}
+	return;
+}
+int HP_script_db_free_code_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_db_free_code_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_db_free_code_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_db_free_code_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.db_free_code_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_db_free_code_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_db_free_code_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_db_free_code_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_script_add_autobonus(const char *autobonus) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_add_autobonus_pre ) {
+		void (*preHookFunc) (const char *autobonus);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_autobonus_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_add_autobonus_pre[hIndex].func;
+			preHookFunc(autobonus);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.add_autobonus(autobonus);
+	}
+	if( HPMHooks.count.HP_script_add_autobonus_post ) {
+		void (*postHookFunc) (const char *autobonus);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_autobonus_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_add_autobonus_post[hIndex].func;
+			postHookFunc(autobonus);
+		}
+	}
+	return;
+}
+int HP_script_menu_countoptions(const char *str, int max_count, int *total) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_menu_countoptions_pre ) {
+		int (*preHookFunc) (const char *str, int *max_count, int *total);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_menu_countoptions_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_menu_countoptions_pre[hIndex].func;
+			retVal___ = preHookFunc(str, &max_count, total);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.menu_countoptions(str, max_count, total);
+	}
+	if( HPMHooks.count.HP_script_menu_countoptions_post ) {
+		int (*postHookFunc) (int retVal___, const char *str, int *max_count, int *total);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_menu_countoptions_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_menu_countoptions_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, &max_count, total);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_areawarp_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_areawarp_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_areawarp_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_areawarp_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_areawarp_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_areawarp_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_areawarp_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_areawarp_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_areapercentheal_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_areapercentheal_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_areapercentheal_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_areapercentheal_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_areapercentheal_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_areapercentheal_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_areapercentheal_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_areapercentheal_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int32 HP_script_getarraysize(struct script_state *st, int32 id, int32 idx, int isstring, struct DBMap **ref) {
+	int hIndex = 0;
+	int32 retVal___;
+	memset(&retVal___, '\0', sizeof(int32));
+	if( HPMHooks.count.HP_script_getarraysize_pre ) {
+		int32 (*preHookFunc) (struct script_state *st, int32 *id, int32 *idx, int *isstring, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_getarraysize_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_getarraysize_pre[hIndex].func;
+			retVal___ = preHookFunc(st, &id, &idx, &isstring, ref);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.getarraysize(st, id, idx, isstring, ref);
+	}
+	if( HPMHooks.count.HP_script_getarraysize_post ) {
+		int32 (*postHookFunc) (int32 retVal___, struct script_state *st, int32 *id, int32 *idx, int *isstring, struct DBMap **ref);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_getarraysize_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_getarraysize_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st, &id, &idx, &isstring, ref);
+		}
+	}
+	return retVal___;
+}
+void HP_script_buildin_delitem_delete(struct map_session_data *sd, int idx, int *amount, bool delete_items) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_script_buildin_delitem_delete_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount, bool *delete_items);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_delete_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_buildin_delitem_delete_pre[hIndex].func;
+			preHookFunc(sd, &idx, amount, &delete_items);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.script.buildin_delitem_delete(sd, idx, amount, delete_items);
+	}
+	if( HPMHooks.count.HP_script_buildin_delitem_delete_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *idx, int *amount, bool *delete_items);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_delete_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_buildin_delitem_delete_post[hIndex].func;
+			postHookFunc(sd, &idx, amount, &delete_items);
+		}
+	}
+	return;
+}
+bool HP_script_buildin_delitem_search(struct map_session_data *sd, struct item *it, bool exact_match) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_script_buildin_delitem_search_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, struct item *it, bool *exact_match);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_buildin_delitem_search_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, it, &exact_match);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.buildin_delitem_search(sd, it, exact_match);
+	}
+	if( HPMHooks.count.HP_script_buildin_delitem_search_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct item *it, bool *exact_match);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_buildin_delitem_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, it, &exact_match);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_killmonster_sub_strip(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_killmonster_sub_strip_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonster_sub_strip_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_killmonster_sub_strip_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_killmonster_sub_strip(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_killmonster_sub_strip_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonster_sub_strip_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_killmonster_sub_strip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_killmonster_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_killmonster_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonster_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_killmonster_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_killmonster_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_killmonster_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonster_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_killmonster_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_killmonsterall_sub_strip(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_killmonsterall_sub_strip_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_killmonsterall_sub_strip(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_killmonsterall_sub_strip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_killmonsterall_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonsterall_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_killmonsterall_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_killmonsterall_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonsterall_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_killmonsterall_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_announce_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_announce_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_announce_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_announce_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_announce_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_announce_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_announce_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_announce_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_getareausers_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_getareausers_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_getareausers_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_getareausers_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_getareausers_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_getareausers_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_getareausers_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_getareausers_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_getareadropitem_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_getareadropitem_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_getareadropitem_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_getareadropitem_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_getareadropitem_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_getareadropitem_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_getareadropitem_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_getareadropitem_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_mapflag_pvp_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_mapflag_pvp_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_mapflag_pvp_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_mapflag_pvp_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.mapflag_pvp_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_mapflag_pvp_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_mapflag_pvp_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_mapflag_pvp_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_pvpoff_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_pvpoff_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_pvpoff_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_pvpoff_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_pvpoff_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_pvpoff_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_pvpoff_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_pvpoff_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_maprespawnguildid_sub_pc(struct map_session_data *sd, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_maprespawnguildid_sub_pc_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_maprespawnguildid_sub_pc(sd, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_maprespawnguildid_sub_pc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_maprespawnguildid_sub_mob(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_maprespawnguildid_sub_mob_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_maprespawnguildid_sub_mob(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_maprespawnguildid_sub_mob_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_mobcount_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_mobcount_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_mobcount_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_mobcount_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_mobcount_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_mobcount_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_mobcount_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_mobcount_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_playBGM_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_playBGM_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_playBGM_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_playBGM_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.playBGM_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_playBGM_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_playBGM_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_playBGM_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_playBGM_foreachpc_sub(struct map_session_data *sd, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_playBGM_foreachpc_sub_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_playBGM_foreachpc_sub_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_script_playBGM_foreachpc_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.script.playBGM_foreachpc_sub(sd, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_script_playBGM_foreachpc_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_playBGM_foreachpc_sub_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_script_playBGM_foreachpc_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_soundeffect_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_soundeffect_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_soundeffect_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_soundeffect_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.soundeffect_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_soundeffect_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_soundeffect_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_soundeffect_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_query_sql_sub(struct script_state *st, Sql *handle) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_query_sql_sub_pre ) {
+		int (*preHookFunc) (struct script_state *st, Sql *handle);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_query_sql_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_buildin_query_sql_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(st, handle);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.buildin_query_sql_sub(st, handle);
+	}
+	if( HPMHooks.count.HP_script_buildin_query_sql_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct script_state *st, Sql *handle);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_query_sql_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_buildin_query_sql_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st, handle);
+		}
+	}
+	return retVal___;
+}
+int HP_script_axtoi(const char *hexStg) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_axtoi_pre ) {
+		int (*preHookFunc) (const char *hexStg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_axtoi_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_axtoi_pre[hIndex].func;
+			retVal___ = preHookFunc(hexStg);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.axtoi(hexStg);
+	}
+	if( HPMHooks.count.HP_script_axtoi_post ) {
+		int (*postHookFunc) (int retVal___, const char *hexStg);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_axtoi_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_axtoi_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hexStg);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_instance_warpall_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_instance_warpall_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_instance_warpall_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_instance_warpall_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_instance_warpall_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_instance_warpall_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_instance_warpall_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_instance_warpall_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_buildin_mobuseskill_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_buildin_mobuseskill_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_mobuseskill_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_buildin_mobuseskill_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.buildin_mobuseskill_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_buildin_mobuseskill_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_mobuseskill_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_buildin_mobuseskill_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_cleanfloor_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_cleanfloor_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_cleanfloor_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_script_cleanfloor_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.script.cleanfloor_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_script_cleanfloor_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_cleanfloor_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_script_cleanfloor_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_script_run_func(struct script_state *st) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_script_run_func_pre ) {
+		int (*preHookFunc) (struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_func_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_script_run_func_pre[hIndex].func;
+			retVal___ = preHookFunc(st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.script.run_func(st);
+	}
+	if( HPMHooks.count.HP_script_run_func_post ) {
+		int (*postHookFunc) (int retVal___, struct script_state *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_func_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_script_run_func_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, st);
+		}
+	}
+	return retVal___;
+}
+/* searchstore */
+bool HP_searchstore_open(struct map_session_data *sd, unsigned int uses, unsigned short effect) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_searchstore_open_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, unsigned int *uses, unsigned short *effect);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_open_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_open_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &uses, &effect);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.searchstore.open(sd, uses, effect);
+	}
+	if( HPMHooks.count.HP_searchstore_open_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int *uses, unsigned short *effect);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_open_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_open_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &uses, &effect);
+		}
+	}
+	return retVal___;
+}
+void HP_searchstore_query(struct map_session_data *sd, unsigned char type, unsigned int min_price, unsigned int max_price, const unsigned short *itemlist, unsigned int item_count, const unsigned short *cardlist, unsigned int card_count) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_searchstore_query_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned char *type, unsigned int *min_price, unsigned int *max_price, const unsigned short *itemlist, unsigned int *item_count, const unsigned short *cardlist, unsigned int *card_count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_query_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_query_pre[hIndex].func;
+			preHookFunc(sd, &type, &min_price, &max_price, itemlist, &item_count, cardlist, &card_count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.searchstore.query(sd, type, min_price, max_price, itemlist, item_count, cardlist, card_count);
+	}
+	if( HPMHooks.count.HP_searchstore_query_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned char *type, unsigned int *min_price, unsigned int *max_price, const unsigned short *itemlist, unsigned int *item_count, const unsigned short *cardlist, unsigned int *card_count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_query_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_query_post[hIndex].func;
+			postHookFunc(sd, &type, &min_price, &max_price, itemlist, &item_count, cardlist, &card_count);
+		}
+	}
+	return;
+}
+bool HP_searchstore_querynext(struct map_session_data *sd) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_searchstore_querynext_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_querynext_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_querynext_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.searchstore.querynext(sd);
+	}
+	if( HPMHooks.count.HP_searchstore_querynext_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_querynext_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_querynext_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+void HP_searchstore_next(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_searchstore_next_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_next_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_next_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.searchstore.next(sd);
+	}
+	if( HPMHooks.count.HP_searchstore_next_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_next_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_next_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_searchstore_clear(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_searchstore_clear_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_clear_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.searchstore.clear(sd);
+	}
+	if( HPMHooks.count.HP_searchstore_clear_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_clear_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_searchstore_close(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_searchstore_close_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_close_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.searchstore.close(sd);
+	}
+	if( HPMHooks.count.HP_searchstore_close_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_close_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_searchstore_click(struct map_session_data *sd, int account_id, int store_id, unsigned short nameid) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_searchstore_click_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *account_id, int *store_id, unsigned short *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_click_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_click_pre[hIndex].func;
+			preHookFunc(sd, &account_id, &store_id, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.searchstore.click(sd, account_id, store_id, nameid);
+	}
+	if( HPMHooks.count.HP_searchstore_click_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *account_id, int *store_id, unsigned short *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_click_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_click_post[hIndex].func;
+			postHookFunc(sd, &account_id, &store_id, &nameid);
+		}
+	}
+	return;
+}
+bool HP_searchstore_queryremote(struct map_session_data *sd, int account_id) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_searchstore_queryremote_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_queryremote_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_queryremote_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &account_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.searchstore.queryremote(sd, account_id);
+	}
+	if( HPMHooks.count.HP_searchstore_queryremote_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int *account_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_queryremote_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_queryremote_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &account_id);
+		}
+	}
+	return retVal___;
+}
+void HP_searchstore_clearremote(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_searchstore_clearremote_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clearremote_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_clearremote_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.searchstore.clearremote(sd);
+	}
+	if( HPMHooks.count.HP_searchstore_clearremote_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clearremote_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_clearremote_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+bool HP_searchstore_result(struct map_session_data *sd, unsigned int store_id, int account_id, const char *store_name, unsigned short nameid, unsigned short amount, unsigned int price, const short *card, unsigned char refine) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_searchstore_result_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, unsigned int *store_id, int *account_id, const char *store_name, unsigned short *nameid, unsigned short *amount, unsigned int *price, const short *card, unsigned char *refine);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_result_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_searchstore_result_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &store_id, &account_id, store_name, &nameid, &amount, &price, card, &refine);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.searchstore.result(sd, store_id, account_id, store_name, nameid, amount, price, card, refine);
+	}
+	if( HPMHooks.count.HP_searchstore_result_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int *store_id, int *account_id, const char *store_name, unsigned short *nameid, unsigned short *amount, unsigned int *price, const short *card, unsigned char *refine);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_result_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_searchstore_result_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &store_id, &account_id, store_name, &nameid, &amount, &price, card, &refine);
+		}
+	}
+	return retVal___;
+}
+/* skill */
+int HP_skill_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.init();
+	}
+	if( HPMHooks.count.HP_skill_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_final(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_final_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_final_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.final();
+	}
+	if( HPMHooks.count.HP_skill_final_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_reload(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_reload_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_reload_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_reload_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.reload();
+	}
+	if( HPMHooks.count.HP_skill_reload_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_reload_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_reload_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_skill_read_db(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_read_db_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_read_db_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_read_db_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.read_db();
+	}
+	if( HPMHooks.count.HP_skill_read_db_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_read_db_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_read_db_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_skill_get_index(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_index_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_index_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_index_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_index(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_index_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_index_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_index_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_type(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_type_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_type_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_type_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_type(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_type_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_type_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_type_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_hit(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_hit_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_hit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_hit_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_hit(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_hit_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_hit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_hit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_inf(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_inf_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_inf_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_inf_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_inf(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_inf_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_inf_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_inf_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_ele(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_ele_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ele_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_ele_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_ele(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_ele_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ele_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_ele_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_nk(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_nk_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_nk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_nk_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_nk(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_nk_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_nk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_nk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_max(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_max_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_max_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_max_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_max(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_max_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_max_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_max_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_range(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_range_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_range_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_range(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_range_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_range_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_range2(struct block_list *bl, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_range2_pre ) {
+		int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_range2_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_range2(bl, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_range2_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_range2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_splash(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_splash_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_splash_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_splash_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_splash(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_splash_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_splash_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_splash_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_hp(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_hp_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_hp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_hp_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_hp(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_hp_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_hp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_hp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_mhp(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_mhp_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_mhp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_mhp_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_mhp(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_mhp_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_mhp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_mhp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_sp(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_sp_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_sp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_sp_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_sp(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_sp_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_sp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_sp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_state(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_state_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_state_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_state_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_state(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_state_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_state_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_state_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_spiritball(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_spiritball_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_spiritball_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_spiritball_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_spiritball(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_spiritball_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_spiritball_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_spiritball_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_zeny(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_zeny_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_zeny_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_zeny_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_zeny(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_zeny_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_zeny_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_zeny_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_num(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_num_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_num_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_num_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_num(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_num_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_num_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_num_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_cast(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_cast_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_cast_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_cast_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_cast(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_cast_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_cast_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_cast_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_delay(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_delay_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_delay_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_delay_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_delay(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_delay_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_delay_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_delay_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_walkdelay(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_walkdelay_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_walkdelay_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_walkdelay_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_walkdelay(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_walkdelay_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_walkdelay_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_walkdelay_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_time(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_time_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_time_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_time_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_time(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_time_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_time_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_time_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_time2(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_time2_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_time2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_time2_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_time2(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_time2_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_time2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_time2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_castnodex(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_castnodex_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castnodex_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_castnodex_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_castnodex(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_castnodex_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castnodex_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_castnodex_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_delaynodex(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_delaynodex_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_delaynodex_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_delaynodex_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_delaynodex(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_delaynodex_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_delaynodex_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_delaynodex_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_castdef(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_castdef_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castdef_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_castdef_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_castdef(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_castdef_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castdef_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_castdef_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_weapontype(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_weapontype_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_weapontype_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_weapontype_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_weapontype(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_weapontype_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_weapontype_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_weapontype_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_ammotype(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_ammotype_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ammotype_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_ammotype_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_ammotype(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_ammotype_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ammotype_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_ammotype_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_ammo_qty(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_ammo_qty_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ammo_qty_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_ammo_qty_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_ammo_qty(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_ammo_qty_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ammo_qty_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_ammo_qty_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_unit_id(uint16 skill_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_unit_id_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_unit_id_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_unit_id(skill_id, flag);
+	}
+	if( HPMHooks.count.HP_skill_get_unit_id_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_unit_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_inf2(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_inf2_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_inf2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_inf2_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_inf2(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_inf2_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_inf2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_inf2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_castcancel(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_castcancel_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castcancel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_castcancel_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_castcancel(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_castcancel_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castcancel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_castcancel_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_maxcount(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_maxcount_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_maxcount_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_maxcount_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_maxcount(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_maxcount_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_maxcount_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_maxcount_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_blewcount(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_blewcount_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_blewcount_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_blewcount_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_blewcount(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_blewcount_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_blewcount_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_blewcount_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_unit_flag(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_unit_flag_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_flag_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_unit_flag_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_unit_flag(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_unit_flag_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_flag_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_unit_flag_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_unit_target(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_unit_target_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_target_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_unit_target_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_unit_target(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_unit_target_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_target_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_unit_target_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_unit_interval(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_unit_interval_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_interval_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_unit_interval_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_unit_interval(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_unit_interval_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_interval_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_unit_interval_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_unit_bl_target(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_unit_bl_target_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_bl_target_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_unit_bl_target_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_unit_bl_target(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_unit_bl_target_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_bl_target_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_unit_bl_target_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_unit_layout_type(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_unit_layout_type_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_type_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_unit_layout_type_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_unit_layout_type(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_unit_layout_type_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_type_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_unit_layout_type_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_unit_range(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_unit_range_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_range_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_unit_range_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_unit_range(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_unit_range_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_range_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_unit_range_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_cooldown(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_cooldown_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_cooldown_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_cooldown_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_cooldown(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_cooldown_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_cooldown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_cooldown_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_tree_get_max(uint16 skill_id, int b_class) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_tree_get_max_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, int *b_class);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_tree_get_max_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_tree_get_max_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &b_class);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.tree_get_max(skill_id, b_class);
+	}
+	if( HPMHooks.count.HP_skill_tree_get_max_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, int *b_class);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_tree_get_max_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_tree_get_max_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &b_class);
+		}
+	}
+	return retVal___;
+}
+const char* HP_skill_get_name(uint16 skill_id) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_get_name_pre ) {
+		const char* (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_name_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_name(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_name_post ) {
+		const char* (*postHookFunc) (const char* retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_name_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+const char* HP_skill_get_desc(uint16 skill_id) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_get_desc_pre ) {
+		const char* (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_desc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_desc_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_desc(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_desc_post ) {
+		const char* (*postHookFunc) (const char* retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_desc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_desc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_chk(uint16 *skill_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_chk_pre ) {
+		void (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_chk_pre[hIndex].func;
+			preHookFunc(skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.chk(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_chk_post ) {
+		void (*postHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_chk_post[hIndex].func;
+			postHookFunc(skill_id);
+		}
+	}
+	return;
+}
+int HP_skill_get_casttype(uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_casttype_pre ) {
+		int (*preHookFunc) (uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_casttype_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_casttype_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_casttype(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_get_casttype_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_casttype_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_casttype_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_casttype2(uint16 index) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_casttype2_pre ) {
+		int (*preHookFunc) (uint16 *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_casttype2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_casttype2_pre[hIndex].func;
+			retVal___ = preHookFunc(&index);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_casttype2(index);
+	}
+	if( HPMHooks.count.HP_skill_get_casttype2_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *index);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_casttype2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_casttype2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &index);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_name2id(const char *name) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_name2id_pre ) {
+		int (*preHookFunc) (const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_name2id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_name2id_pre[hIndex].func;
+			retVal___ = preHookFunc(name);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.name2id(name);
+	}
+	if( HPMHooks.count.HP_skill_name2id_post ) {
+		int (*postHookFunc) (int retVal___, const char *name);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_name2id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_name2id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, name);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_isammotype(struct map_session_data *sd, int skill) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_isammotype_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *skill);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_isammotype_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_isammotype_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.isammotype(sd, skill);
+	}
+	if( HPMHooks.count.HP_skill_isammotype_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *skill);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_isammotype_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_isammotype_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_castend_id(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_castend_id_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_castend_id_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.castend_id(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_skill_castend_id_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_castend_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_castend_pos(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_castend_pos_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_castend_pos_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.castend_pos(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_skill_castend_pos_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_castend_pos_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_castend_map(struct map_session_data *sd, uint16 skill_id, const char *mapname) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_castend_map_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, const char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_map_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_castend_map_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, mapname);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.castend_map(sd, skill_id, mapname);
+	}
+	if( HPMHooks.count.HP_skill_castend_map_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, const char *mapname);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_map_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_castend_map_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, mapname);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_cleartimerskill(struct block_list *src) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_cleartimerskill_pre ) {
+		int (*preHookFunc) (struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_cleartimerskill_pre[hIndex].func;
+			retVal___ = preHookFunc(src);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.cleartimerskill(src);
+	}
+	if( HPMHooks.count.HP_skill_cleartimerskill_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_cleartimerskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_addtimerskill(struct block_list *src, unsigned int tick, int target, int x, int y, uint16 skill_id, uint16 skill_lv, int type, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_addtimerskill_pre ) {
+		int (*preHookFunc) (struct block_list *src, unsigned int *tick, int *target, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int *type, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_addtimerskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_addtimerskill_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &tick, &target, &x, &y, &skill_id, &skill_lv, &type, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.addtimerskill(src, tick, target, x, y, skill_id, skill_lv, type, flag);
+	}
+	if( HPMHooks.count.HP_skill_addtimerskill_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, unsigned int *tick, int *target, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int *type, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_addtimerskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_addtimerskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &tick, &target, &x, &y, &skill_id, &skill_lv, &type, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_additional_effect(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int dmg_lv, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_additional_effect_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_additional_effect_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &attack_type, &dmg_lv, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.additional_effect(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick);
+	}
+	if( HPMHooks.count.HP_skill_additional_effect_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_additional_effect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &attack_type, &dmg_lv, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_counter_additional_effect(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_counter_additional_effect_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &attack_type, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.counter_additional_effect(src, bl, skill_id, skill_lv, attack_type, tick);
+	}
+	if( HPMHooks.count.HP_skill_counter_additional_effect_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &attack_type, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_blown(struct block_list *src, struct block_list *target, int count, int8 dir, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_blown_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, int *count, int8 *dir, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blown_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_blown_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &count, &dir, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.blown(src, target, count, dir, flag);
+	}
+	if( HPMHooks.count.HP_skill_blown_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int *count, int8 *dir, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_blown_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &count, &dir, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_break_equip(struct block_list *bl, unsigned short where, int rate, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_break_equip_pre ) {
+		int (*preHookFunc) (struct block_list *bl, unsigned short *where, int *rate, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_break_equip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_break_equip_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &where, &rate, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.break_equip(bl, where, rate, flag);
+	}
+	if( HPMHooks.count.HP_skill_break_equip_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned short *where, int *rate, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_break_equip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_break_equip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &where, &rate, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_strip_equip(struct block_list *bl, unsigned short where, int rate, int lv, int time) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_strip_equip_pre ) {
+		int (*preHookFunc) (struct block_list *bl, unsigned short *where, int *rate, int *lv, int *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_strip_equip_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_strip_equip_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &where, &rate, &lv, &time);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.strip_equip(bl, where, rate, lv, time);
+	}
+	if( HPMHooks.count.HP_skill_strip_equip_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned short *where, int *rate, int *lv, int *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_strip_equip_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_strip_equip_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &where, &rate, &lv, &time);
+		}
+	}
+	return retVal___;
+}
+struct skill_unit_group* HP_skill_id2group(int group_id) {
+	int hIndex = 0;
+	struct skill_unit_group* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_id2group_pre ) {
+		struct skill_unit_group* (*preHookFunc) (int *group_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_id2group_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_id2group_pre[hIndex].func;
+			retVal___ = preHookFunc(&group_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.id2group(group_id);
+	}
+	if( HPMHooks.count.HP_skill_id2group_post ) {
+		struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, int *group_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_id2group_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_id2group_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &group_id);
+		}
+	}
+	return retVal___;
+}
+struct skill_unit_group* HP_skill_unitsetting(struct block_list *src, uint16 skill_id, uint16 skill_lv, short x, short y, int flag) {
+	int hIndex = 0;
+	struct skill_unit_group* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_unitsetting_pre ) {
+		struct skill_unit_group* (*preHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unitsetting_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &skill_id, &skill_lv, &x, &y, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unitsetting(src, skill_id, skill_lv, x, y, flag);
+	}
+	if( HPMHooks.count.HP_skill_unitsetting_post ) {
+		struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *src, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unitsetting_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &skill_id, &skill_lv, &x, &y, &flag);
+		}
+	}
+	return retVal___;
+}
+struct skill_unit* HP_skill_initunit(struct skill_unit_group *group, int idx, int x, int y, int val1, int val2) {
+	int hIndex = 0;
+	struct skill_unit* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_initunit_pre ) {
+		struct skill_unit* (*preHookFunc) (struct skill_unit_group *group, int *idx, int *x, int *y, int *val1, int *val2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_initunit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_initunit_pre[hIndex].func;
+			retVal___ = preHookFunc(group, &idx, &x, &y, &val1, &val2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.initunit(group, idx, x, y, val1, val2);
+	}
+	if( HPMHooks.count.HP_skill_initunit_post ) {
+		struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, struct skill_unit_group *group, int *idx, int *x, int *y, int *val1, int *val2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_initunit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_initunit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, group, &idx, &x, &y, &val1, &val2);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_delunit(struct skill_unit *su) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_delunit_pre ) {
+		int (*preHookFunc) (struct skill_unit *su);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delunit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_delunit_pre[hIndex].func;
+			retVal___ = preHookFunc(su);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.delunit(su);
+	}
+	if( HPMHooks.count.HP_skill_delunit_post ) {
+		int (*postHookFunc) (int retVal___, struct skill_unit *su);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delunit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_delunit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, su);
+		}
+	}
+	return retVal___;
+}
+struct skill_unit_group* HP_skill_init_unitgroup(struct block_list *src, int count, uint16 skill_id, uint16 skill_lv, int unit_id, int limit, int interval) {
+	int hIndex = 0;
+	struct skill_unit_group* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_init_unitgroup_pre ) {
+		struct skill_unit_group* (*preHookFunc) (struct block_list *src, int *count, uint16 *skill_id, uint16 *skill_lv, int *unit_id, int *limit, int *interval);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unitgroup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_init_unitgroup_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &count, &skill_id, &skill_lv, &unit_id, &limit, &interval);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.init_unitgroup(src, count, skill_id, skill_lv, unit_id, limit, interval);
+	}
+	if( HPMHooks.count.HP_skill_init_unitgroup_post ) {
+		struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *src, int *count, uint16 *skill_id, uint16 *skill_lv, int *unit_id, int *limit, int *interval);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unitgroup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_init_unitgroup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &count, &skill_id, &skill_lv, &unit_id, &limit, &interval);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_del_unitgroup(struct skill_unit_group *group, const char *file, int line, const char *func) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_del_unitgroup_pre ) {
+		int (*preHookFunc) (struct skill_unit_group *group, const char *file, int *line, const char *func);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_del_unitgroup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_del_unitgroup_pre[hIndex].func;
+			retVal___ = preHookFunc(group, file, &line, func);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.del_unitgroup(group, file, line, func);
+	}
+	if( HPMHooks.count.HP_skill_del_unitgroup_post ) {
+		int (*postHookFunc) (int retVal___, struct skill_unit_group *group, const char *file, int *line, const char *func);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_del_unitgroup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_del_unitgroup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, group, file, &line, func);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_clear_unitgroup(struct block_list *src) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_clear_unitgroup_pre ) {
+		int (*preHookFunc) (struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_unitgroup_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_clear_unitgroup_pre[hIndex].func;
+			retVal___ = preHookFunc(src);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.clear_unitgroup(src);
+	}
+	if( HPMHooks.count.HP_skill_clear_unitgroup_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_unitgroup_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_clear_unitgroup_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_clear_group(struct block_list *bl, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_clear_group_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_group_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_clear_group_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.clear_group(bl, flag);
+	}
+	if( HPMHooks.count.HP_skill_clear_group_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_group_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_clear_group_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_onplace(struct skill_unit *src, struct block_list *bl, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_onplace_pre ) {
+		int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unit_onplace_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unit_onplace(src, bl, tick);
+	}
+	if( HPMHooks.count.HP_skill_unit_onplace_post ) {
+		int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unit_onplace_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_ondamaged(struct skill_unit *src, struct block_list *bl, int64 damage, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_ondamaged_pre ) {
+		int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *damage, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_ondamaged_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unit_ondamaged_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &damage, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unit_ondamaged(src, bl, damage, tick);
+	}
+	if( HPMHooks.count.HP_skill_unit_ondamaged_post ) {
+		int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 *damage, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_ondamaged_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unit_ondamaged_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &damage, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_cast_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_cast_fix_pre ) {
+		int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_cast_fix_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.cast_fix(bl, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_cast_fix_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_cast_fix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_cast_fix_sc(struct block_list *bl, int time) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_cast_fix_sc_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_sc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_cast_fix_sc_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &time);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.cast_fix_sc(bl, time);
+	}
+	if( HPMHooks.count.HP_skill_cast_fix_sc_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *time);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_sc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_cast_fix_sc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &time);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_vf_cast_fix(struct block_list *bl, double time, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_vf_cast_fix_pre ) {
+		int (*preHookFunc) (struct block_list *bl, double *time, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_vf_cast_fix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_vf_cast_fix_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &time, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.vf_cast_fix(bl, time, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_vf_cast_fix_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, double *time, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_vf_cast_fix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_vf_cast_fix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &time, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_delay_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_delay_fix_pre ) {
+		int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delay_fix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_delay_fix_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.delay_fix(bl, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_delay_fix_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delay_fix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_delay_fix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_condition_castbegin(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_condition_castbegin_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.check_condition_castbegin(sd, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_check_condition_castbegin_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_condition_castend(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_condition_castend_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_check_condition_castend_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.check_condition_castend(sd, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_check_condition_castend_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_check_condition_castend_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_consume_requirement(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, short type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_consume_requirement_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, short *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_consume_requirement_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_consume_requirement_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, &skill_lv, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.consume_requirement(sd, skill_id, skill_lv, type);
+	}
+	if( HPMHooks.count.HP_skill_consume_requirement_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, short *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_consume_requirement_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_consume_requirement_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv, &type);
+		}
+	}
+	return retVal___;
+}
+struct skill_condition HP_skill_get_requirement(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	struct skill_condition retVal___;
+	memset(&retVal___, '\0', sizeof(struct skill_condition));
+	if( HPMHooks.count.HP_skill_get_requirement_pre ) {
+		struct skill_condition (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_requirement_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_requirement(sd, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_requirement_post ) {
+		struct skill_condition (*postHookFunc) (struct skill_condition retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_requirement_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_pc_partner(struct map_session_data *sd, uint16 skill_id, uint16 *skill_lv, int range, int cast_flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_pc_partner_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, int *range, int *cast_flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_pc_partner_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_check_pc_partner_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, skill_lv, &range, &cast_flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.check_pc_partner(sd, skill_id, skill_lv, range, cast_flag);
+	}
+	if( HPMHooks.count.HP_skill_check_pc_partner_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, int *range, int *cast_flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_pc_partner_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_check_pc_partner_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, skill_lv, &range, &cast_flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_move(struct block_list *bl, unsigned int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_move_pre ) {
+		int (*preHookFunc) (struct block_list *bl, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unit_move_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unit_move(bl, tick, flag);
+	}
+	if( HPMHooks.count.HP_skill_unit_move_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unit_move_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_onleft(uint16 skill_id, struct block_list *bl, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_onleft_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onleft_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unit_onleft_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, bl, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unit_onleft(skill_id, bl, tick);
+	}
+	if( HPMHooks.count.HP_skill_unit_onleft_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onleft_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unit_onleft_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, bl, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_onout(struct skill_unit *src, struct block_list *bl, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_onout_pre ) {
+		int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onout_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unit_onout_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unit_onout(src, bl, tick);
+	}
+	if( HPMHooks.count.HP_skill_unit_onout_post ) {
+		int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onout_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unit_onout_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_move_unit_group(struct skill_unit_group *group, int16 m, int16 dx, int16 dy) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_move_unit_group_pre ) {
+		int (*preHookFunc) (struct skill_unit_group *group, int16 *m, int16 *dx, int16 *dy);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_unit_group_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unit_move_unit_group_pre[hIndex].func;
+			retVal___ = preHookFunc(group, &m, &dx, &dy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unit_move_unit_group(group, m, dx, dy);
+	}
+	if( HPMHooks.count.HP_skill_unit_move_unit_group_post ) {
+		int (*postHookFunc) (int retVal___, struct skill_unit_group *group, int16 *m, int16 *dx, int16 *dy);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_unit_group_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unit_move_unit_group_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, group, &m, &dx, &dy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_sit(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_sit_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_sit_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.sit(sd, type);
+	}
+	if( HPMHooks.count.HP_skill_sit_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_sit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_brandishspear(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, unsigned int tick, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_brandishspear_pre ) {
+		void (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_brandishspear_pre[hIndex].func;
+			preHookFunc(src, bl, &skill_id, &skill_lv, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.brandishspear(src, bl, skill_id, skill_lv, tick, flag);
+	}
+	if( HPMHooks.count.HP_skill_brandishspear_post ) {
+		void (*postHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_brandishspear_post[hIndex].func;
+			postHookFunc(src, bl, &skill_id, &skill_lv, &tick, &flag);
+		}
+	}
+	return;
+}
+void HP_skill_repairweapon(struct map_session_data *sd, int idx) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_repairweapon_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_repairweapon_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_repairweapon_pre[hIndex].func;
+			preHookFunc(sd, &idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.repairweapon(sd, idx);
+	}
+	if( HPMHooks.count.HP_skill_repairweapon_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_repairweapon_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_repairweapon_post[hIndex].func;
+			postHookFunc(sd, &idx);
+		}
+	}
+	return;
+}
+void HP_skill_identify(struct map_session_data *sd, int idx) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_identify_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_identify_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_identify_pre[hIndex].func;
+			preHookFunc(sd, &idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.identify(sd, idx);
+	}
+	if( HPMHooks.count.HP_skill_identify_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_identify_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_identify_post[hIndex].func;
+			postHookFunc(sd, &idx);
+		}
+	}
+	return;
+}
+void HP_skill_weaponrefine(struct map_session_data *sd, int idx) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_weaponrefine_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_weaponrefine_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_weaponrefine_pre[hIndex].func;
+			preHookFunc(sd, &idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.weaponrefine(sd, idx);
+	}
+	if( HPMHooks.count.HP_skill_weaponrefine_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_weaponrefine_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_weaponrefine_post[hIndex].func;
+			postHookFunc(sd, &idx);
+		}
+	}
+	return;
+}
+int HP_skill_autospell(struct map_session_data *md, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_autospell_pre ) {
+		int (*preHookFunc) (struct map_session_data *md, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_autospell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_autospell_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.autospell(md, skill_id);
+	}
+	if( HPMHooks.count.HP_skill_autospell_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *md, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_autospell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_autospell_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_calc_heal(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, bool heal) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_calc_heal_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, bool *heal);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_calc_heal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_calc_heal_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &heal);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.calc_heal(src, target, skill_id, skill_lv, heal);
+	}
+	if( HPMHooks.count.HP_skill_calc_heal_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, bool *heal);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_calc_heal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_calc_heal_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &heal);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_check_cloaking(struct block_list *bl, struct status_change_entry *sce) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_check_cloaking_pre ) {
+		bool (*preHookFunc) (struct block_list *bl, struct status_change_entry *sce);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_cloaking_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_check_cloaking_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sce);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.check_cloaking(bl, sce);
+	}
+	if( HPMHooks.count.HP_skill_check_cloaking_post ) {
+		bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct status_change_entry *sce);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_cloaking_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_check_cloaking_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sce);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_enchant_elemental_end(struct block_list *bl, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_enchant_elemental_end_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_enchant_elemental_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_enchant_elemental_end_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.enchant_elemental_end(bl, type);
+	}
+	if( HPMHooks.count.HP_skill_enchant_elemental_end_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_enchant_elemental_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_enchant_elemental_end_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_not_ok(uint16 skill_id, struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_not_ok_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_not_ok_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.not_ok(skill_id, sd);
+	}
+	if( HPMHooks.count.HP_skill_not_ok_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_not_ok_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_not_ok_hom(uint16 skill_id, struct homun_data *hd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_not_ok_hom_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_hom_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_not_ok_hom_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, hd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.not_ok_hom(skill_id, hd);
+	}
+	if( HPMHooks.count.HP_skill_not_ok_hom_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, struct homun_data *hd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_hom_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_not_ok_hom_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, hd);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_not_ok_mercenary(uint16 skill_id, struct mercenary_data *md) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_not_ok_mercenary_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_mercenary_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_not_ok_mercenary_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, md);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.not_ok_mercenary(skill_id, md);
+	}
+	if( HPMHooks.count.HP_skill_not_ok_mercenary_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, struct mercenary_data *md);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_mercenary_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_not_ok_mercenary_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, md);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_chastle_mob_changetarget(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_chastle_mob_changetarget_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chastle_mob_changetarget_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_chastle_mob_changetarget_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.chastle_mob_changetarget(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_chastle_mob_changetarget_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chastle_mob_changetarget_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_chastle_mob_changetarget_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_can_produce_mix(struct map_session_data *sd, int nameid, int trigger, int qty) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_can_produce_mix_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *trigger, int *qty);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_can_produce_mix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_can_produce_mix_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid, &trigger, &qty);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.can_produce_mix(sd, nameid, trigger, qty);
+	}
+	if( HPMHooks.count.HP_skill_can_produce_mix_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid, int *trigger, int *qty);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_can_produce_mix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_can_produce_mix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid, &trigger, &qty);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid, int slot1, int slot2, int slot3, int qty) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_produce_mix_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *nameid, int *slot1, int *slot2, int *slot3, int *qty);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_produce_mix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_produce_mix_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, &nameid, &slot1, &slot2, &slot3, &qty);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.produce_mix(sd, skill_id, nameid, slot1, slot2, slot3, qty);
+	}
+	if( HPMHooks.count.HP_skill_produce_mix_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, int *nameid, int *slot1, int *slot2, int *slot3, int *qty);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_produce_mix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_produce_mix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, &nameid, &slot1, &slot2, &slot3, &qty);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_arrow_create(struct map_session_data *sd, int nameid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_arrow_create_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_arrow_create_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_arrow_create_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.arrow_create(sd, nameid);
+	}
+	if( HPMHooks.count.HP_skill_arrow_create_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_arrow_create_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_arrow_create_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, unsigned int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_castend_nodamage_id_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.castend_nodamage_id(src, bl, skill_id, skill_lv, tick, flag);
+	}
+	if( HPMHooks.count.HP_skill_castend_nodamage_id_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_castend_damage_id(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, unsigned int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_castend_damage_id_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_castend_damage_id_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &skill_id, &skill_lv, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.castend_damage_id(src, bl, skill_id, skill_lv, tick, flag);
+	}
+	if( HPMHooks.count.HP_skill_castend_damage_id_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_castend_damage_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &skill_id, &skill_lv, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_castend_pos2(struct block_list *src, int x, int y, uint16 skill_id, uint16 skill_lv, unsigned int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_castend_pos2_pre ) {
+		int (*preHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_castend_pos2_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &x, &y, &skill_id, &skill_lv, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.castend_pos2(src, x, y, skill_id, skill_lv, tick, flag);
+	}
+	if( HPMHooks.count.HP_skill_castend_pos2_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_castend_pos2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &x, &y, &skill_id, &skill_lv, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_blockpc_start(struct map_session_data *sd, uint16 skill_id, int tick, bool load) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_blockpc_start_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *tick, bool *load);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_start_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_blockpc_start_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id, &tick, &load);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.blockpc_start(sd, skill_id, tick, load);
+	}
+	if( HPMHooks.count.HP_skill_blockpc_start_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id, int *tick, bool *load);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_start_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_blockpc_start_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id, &tick, &load);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_blockhomun_start(struct homun_data *hd, uint16 skill_id, int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_blockhomun_start_pre ) {
+		int (*preHookFunc) (struct homun_data *hd, uint16 *skill_id, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_start_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_blockhomun_start_pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &skill_id, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.blockhomun_start(hd, skill_id, tick);
+	}
+	if( HPMHooks.count.HP_skill_blockhomun_start_post ) {
+		int (*postHookFunc) (int retVal___, struct homun_data *hd, uint16 *skill_id, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_start_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_blockhomun_start_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &skill_id, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_blockmerc_start(struct mercenary_data *md, uint16 skill_id, int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_blockmerc_start_pre ) {
+		int (*preHookFunc) (struct mercenary_data *md, uint16 *skill_id, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_start_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_blockmerc_start_pre[hIndex].func;
+			retVal___ = preHookFunc(md, &skill_id, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.blockmerc_start(md, skill_id, tick);
+	}
+	if( HPMHooks.count.HP_skill_blockmerc_start_post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md, uint16 *skill_id, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_start_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_blockmerc_start_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &skill_id, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_attack(int attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 skill_id, uint16 skill_lv, unsigned int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_attack_pre ) {
+		int (*preHookFunc) (int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_attack_pre[hIndex].func;
+			retVal___ = preHookFunc(&attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.attack(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
+	}
+	if( HPMHooks.count.HP_skill_attack_post ) {
+		int (*postHookFunc) (int retVal___, int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_attack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &attack_type, src, dsrc, bl, &skill_id, &skill_lv, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_attack_area(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_attack_area_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_area_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_attack_area_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.attack_area(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_attack_area_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_area_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_attack_area_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_area_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_area_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_area_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.area_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_area_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_area_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_area_sub_count(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, unsigned int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_area_sub_count_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_count_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_area_sub_count_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &skill_lv, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.area_sub_count(src, target, skill_id, skill_lv, tick, flag);
+	}
+	if( HPMHooks.count.HP_skill_area_sub_count_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, unsigned int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_count_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_area_sub_count_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &skill_lv, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_unit_range(struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_unit_range_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_check_unit_range_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &x, &y, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.check_unit_range(bl, x, y, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_check_unit_range_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_check_unit_range_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &x, &y, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_unit_range_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_unit_range_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_check_unit_range_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.check_unit_range_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_check_unit_range_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_check_unit_range_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_unit_range2(struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_unit_range2_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_check_unit_range2_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &x, &y, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.check_unit_range2(bl, x, y, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_check_unit_range2_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *x, int *y, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_check_unit_range2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &x, &y, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_unit_range2_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_unit_range2_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_check_unit_range2_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.check_unit_range2_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_check_unit_range2_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_check_unit_range2_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_toggle_magicpower(struct block_list *bl, uint16 skill_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_toggle_magicpower_pre ) {
+		void (*preHookFunc) (struct block_list *bl, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_toggle_magicpower_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_toggle_magicpower_pre[hIndex].func;
+			preHookFunc(bl, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.toggle_magicpower(bl, skill_id);
+	}
+	if( HPMHooks.count.HP_skill_toggle_magicpower_post ) {
+		void (*postHookFunc) (struct block_list *bl, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_toggle_magicpower_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_toggle_magicpower_post[hIndex].func;
+			postHookFunc(bl, &skill_id);
+		}
+	}
+	return;
+}
+int HP_skill_magic_reflect(struct block_list *src, struct block_list *bl, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_magic_reflect_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magic_reflect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_magic_reflect_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.magic_reflect(src, bl, type);
+	}
+	if( HPMHooks.count.HP_skill_magic_reflect_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magic_reflect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_magic_reflect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_onskillusage(struct map_session_data *sd, struct block_list *bl, uint16 skill_id, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_onskillusage_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, uint16 *skill_id, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_onskillusage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_onskillusage_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, bl, &skill_id, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.onskillusage(sd, bl, skill_id, tick);
+	}
+	if( HPMHooks.count.HP_skill_onskillusage_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 *skill_id, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_onskillusage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_onskillusage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, bl, &skill_id, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_cell_overlap(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_cell_overlap_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cell_overlap_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_cell_overlap_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.cell_overlap(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_cell_overlap_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cell_overlap_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_cell_overlap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_timerskill(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_timerskill_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_timerskill_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.timerskill(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_skill_timerskill_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_timerskill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_trap_splash(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_trap_splash_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_trap_splash_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_trap_splash_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.trap_splash(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_trap_splash_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_trap_splash_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_trap_splash_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_condition_mercenary(struct block_list *bl, int skill_id, int lv, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_condition_mercenary_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *skill_id, int *lv, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mercenary_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_check_condition_mercenary_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &skill_id, &lv, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.check_condition_mercenary(bl, skill_id, lv, type);
+	}
+	if( HPMHooks.count.HP_skill_check_condition_mercenary_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *skill_id, int *lv, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mercenary_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_check_condition_mercenary_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &skill_id, &lv, &type);
+		}
+	}
+	return retVal___;
+}
+struct skill_unit_group* HP_skill_locate_element_field(struct block_list *bl) {
+	int hIndex = 0;
+	struct skill_unit_group* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_locate_element_field_pre ) {
+		struct skill_unit_group* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_locate_element_field_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_locate_element_field_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.locate_element_field(bl);
+	}
+	if( HPMHooks.count.HP_skill_locate_element_field_post ) {
+		struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_locate_element_field_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_locate_element_field_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_graffitiremover(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_graffitiremover_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_graffitiremover_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_graffitiremover_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.graffitiremover(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_graffitiremover_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_graffitiremover_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_graffitiremover_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_activate_reverberation(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_activate_reverberation_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_activate_reverberation_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_activate_reverberation_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.activate_reverberation(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_activate_reverberation_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_activate_reverberation_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_activate_reverberation_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_dance_overlap_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_dance_overlap_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_dance_overlap_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.dance_overlap_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_dance_overlap_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_dance_overlap_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_dance_overlap(struct skill_unit *su, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_dance_overlap_pre ) {
+		int (*preHookFunc) (struct skill_unit *su, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_dance_overlap_pre[hIndex].func;
+			retVal___ = preHookFunc(su, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.dance_overlap(su, flag);
+	}
+	if( HPMHooks.count.HP_skill_dance_overlap_post ) {
+		int (*postHookFunc) (int retVal___, struct skill_unit *su, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_dance_overlap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, su, &flag);
+		}
+	}
+	return retVal___;
+}
+struct s_skill_unit_layout* HP_skill_get_unit_layout(uint16 skill_id, uint16 skill_lv, struct block_list *src, int x, int y) {
+	int hIndex = 0;
+	struct s_skill_unit_layout* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_get_unit_layout_pre ) {
+		struct s_skill_unit_layout* (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv, struct block_list *src, int *x, int *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_unit_layout_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv, src, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_unit_layout(skill_id, skill_lv, src, x, y);
+	}
+	if( HPMHooks.count.HP_skill_get_unit_layout_post ) {
+		struct s_skill_unit_layout* (*postHookFunc) (struct s_skill_unit_layout* retVal___, uint16 *skill_id, uint16 *skill_lv, struct block_list *src, int *x, int *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_unit_layout_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv, src, &x, &y);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_frostjoke_scream(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_frostjoke_scream_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_frostjoke_scream_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_frostjoke_scream_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.frostjoke_scream(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_frostjoke_scream_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_frostjoke_scream_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_frostjoke_scream_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_greed(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_greed_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_greed_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_greed_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.greed(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_greed_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_greed_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_greed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_destroy_trap(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_destroy_trap_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_destroy_trap_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_destroy_trap_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.destroy_trap(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_destroy_trap_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_destroy_trap_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_destroy_trap_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_icewall_block(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_icewall_block_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_icewall_block_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_icewall_block_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.icewall_block(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_icewall_block_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_icewall_block_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_icewall_block_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+struct skill_unit_group_tickset* HP_skill_unitgrouptickset_search(struct block_list *bl, struct skill_unit_group *group, int tick) {
+	int hIndex = 0;
+	struct skill_unit_group_tickset* retVal___ = NULL;
+	if( HPMHooks.count.HP_skill_unitgrouptickset_search_pre ) {
+		struct skill_unit_group_tickset* (*preHookFunc) (struct block_list *bl, struct skill_unit_group *group, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitgrouptickset_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unitgrouptickset_search_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, group, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unitgrouptickset_search(bl, group, tick);
+	}
+	if( HPMHooks.count.HP_skill_unitgrouptickset_search_post ) {
+		struct skill_unit_group_tickset* (*postHookFunc) (struct skill_unit_group_tickset* retVal___, struct block_list *bl, struct skill_unit_group *group, int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitgrouptickset_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unitgrouptickset_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, group, &tick);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_dance_switch(struct skill_unit *su, int flag) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_dance_switch_pre ) {
+		bool (*preHookFunc) (struct skill_unit *su, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_switch_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_dance_switch_pre[hIndex].func;
+			retVal___ = preHookFunc(su, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.dance_switch(su, flag);
+	}
+	if( HPMHooks.count.HP_skill_dance_switch_post ) {
+		bool (*postHookFunc) (bool retVal___, struct skill_unit *su, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_switch_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_dance_switch_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, su, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_condition_char_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_condition_char_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_char_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_check_condition_char_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.check_condition_char_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_check_condition_char_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_char_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_check_condition_char_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_check_condition_mob_master_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_check_condition_mob_master_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mob_master_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_check_condition_mob_master_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.check_condition_mob_master_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_check_condition_mob_master_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mob_master_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_check_condition_mob_master_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int16 y) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_brandishspear_first_pre ) {
+		void (*preHookFunc) (struct square *tc, uint8 *dir, int16 *x, int16 *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_first_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_brandishspear_first_pre[hIndex].func;
+			preHookFunc(tc, &dir, &x, &y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.brandishspear_first(tc, dir, x, y);
+	}
+	if( HPMHooks.count.HP_skill_brandishspear_first_post ) {
+		void (*postHookFunc) (struct square *tc, uint8 *dir, int16 *x, int16 *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_first_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_brandishspear_first_post[hIndex].func;
+			postHookFunc(tc, &dir, &x, &y);
+		}
+	}
+	return;
+}
+void HP_skill_brandishspear_dir(struct square *tc, uint8 dir, int are) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_brandishspear_dir_pre ) {
+		void (*preHookFunc) (struct square *tc, uint8 *dir, int *are);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_dir_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_brandishspear_dir_pre[hIndex].func;
+			preHookFunc(tc, &dir, &are);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.brandishspear_dir(tc, dir, are);
+	}
+	if( HPMHooks.count.HP_skill_brandishspear_dir_post ) {
+		void (*postHookFunc) (struct square *tc, uint8 *dir, int *are);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_dir_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_brandishspear_dir_post[hIndex].func;
+			postHookFunc(tc, &dir, &are);
+		}
+	}
+	return;
+}
+int HP_skill_get_fixed_cast(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_fixed_cast_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_fixed_cast_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_fixed_cast_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_fixed_cast(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_fixed_cast_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_fixed_cast_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_fixed_cast_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_sit_count(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_sit_count_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_count_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_sit_count_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.sit_count(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_sit_count_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_count_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_sit_count_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_sit_in(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_sit_in_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_in_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_sit_in_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.sit_in(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_sit_in_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_in_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_sit_in_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_sit_out(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_sit_out_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_out_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_sit_out_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.sit_out(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_sit_out_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_out_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_sit_out_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_unitsetmapcell(struct skill_unit *src, uint16 skill_id, uint16 skill_lv, cell_t cell, bool flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_unitsetmapcell_pre ) {
+		void (*preHookFunc) (struct skill_unit *src, uint16 *skill_id, uint16 *skill_lv, cell_t *cell, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetmapcell_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unitsetmapcell_pre[hIndex].func;
+			preHookFunc(src, &skill_id, &skill_lv, &cell, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.unitsetmapcell(src, skill_id, skill_lv, cell, flag);
+	}
+	if( HPMHooks.count.HP_skill_unitsetmapcell_post ) {
+		void (*postHookFunc) (struct skill_unit *src, uint16 *skill_id, uint16 *skill_lv, cell_t *cell, bool *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetmapcell_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unitsetmapcell_post[hIndex].func;
+			postHookFunc(src, &skill_id, &skill_lv, &cell, &flag);
+		}
+	}
+	return;
+}
+int HP_skill_unit_onplace_timer(struct skill_unit *src, struct block_list *bl, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_onplace_timer_pre ) {
+		int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unit_onplace_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unit_onplace_timer(src, bl, tick);
+	}
+	if( HPMHooks.count.HP_skill_unit_onplace_timer_post ) {
+		int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unit_onplace_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_effect(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_effect_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_effect_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_unit_effect_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.unit_effect(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_unit_effect_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_effect_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_unit_effect_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_timer_sub_onplace(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_timer_sub_onplace_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_onplace_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_onplace_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.unit_timer_sub_onplace(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_unit_timer_sub_onplace_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_onplace_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_onplace_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_move_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_move_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_unit_move_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.unit_move_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_unit_move_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_unit_move_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_blockpc_end(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_blockpc_end_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_blockpc_end_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.blockpc_end(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_skill_blockpc_end_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_blockpc_end_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_blockhomun_end(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_blockhomun_end_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_blockhomun_end_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.blockhomun_end(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_skill_blockhomun_end_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_blockhomun_end_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_blockmerc_end(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_blockmerc_end_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_end_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_blockmerc_end_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.blockmerc_end(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_skill_blockmerc_end_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_end_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_blockmerc_end_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_split_atoi(char *str, int *val) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_split_atoi_pre ) {
+		int (*preHookFunc) (char *str, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_split_atoi_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_split_atoi_pre[hIndex].func;
+			retVal___ = preHookFunc(str, val);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.split_atoi(str, val);
+	}
+	if( HPMHooks.count.HP_skill_split_atoi_post ) {
+		int (*postHookFunc) (int retVal___, char *str, int *val);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_split_atoi_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_split_atoi_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, str, val);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_unit_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.unit_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_skill_unit_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_unit_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_unit_timer_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_unit_timer_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.unit_timer_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_unit_timer_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_init_unit_layout(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_init_unit_layout_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unit_layout_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_init_unit_layout_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.init_unit_layout();
+	}
+	if( HPMHooks.count.HP_skill_init_unit_layout_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unit_layout_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_init_unit_layout_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+bool HP_skill_parse_row_skilldb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_skilldb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_skilldb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_skilldb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_skilldb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_skilldb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_skilldb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_skilldb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_requiredb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_requiredb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_requiredb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_requiredb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_requiredb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_requiredb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_requiredb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_requiredb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_castdb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_castdb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_castdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_castdb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_castdb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_castdb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_castdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_castdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_castnodexdb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_castnodexdb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_castnodexdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_castnodexdb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_castnodexdb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_castnodexdb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_castnodexdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_castnodexdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_unitdb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_unitdb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_unitdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_unitdb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_unitdb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_unitdb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_unitdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_unitdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_producedb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_producedb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_producedb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_producedb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_producedb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_producedb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_producedb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_producedb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_createarrowdb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_createarrowdb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_createarrowdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_createarrowdb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_createarrowdb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_createarrowdb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_createarrowdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_createarrowdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_abradb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_abradb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_abradb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_abradb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_abradb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_abradb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_abradb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_abradb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_spellbookdb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_spellbookdb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_spellbookdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_spellbookdb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_spellbookdb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_spellbookdb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_spellbookdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_spellbookdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_magicmushroomdb(char *split[], int column, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_magicmushroomdb_pre ) {
+		bool (*preHookFunc) (char *split[], int *column, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_magicmushroomdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_magicmushroomdb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &column, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_magicmushroomdb(split, column, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_magicmushroomdb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *column, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_magicmushroomdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_magicmushroomdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &column, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_reproducedb(char *split[], int column, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_reproducedb_pre ) {
+		bool (*preHookFunc) (char *split[], int *column, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_reproducedb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_reproducedb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &column, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_reproducedb(split, column, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_reproducedb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *column, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_reproducedb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_reproducedb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &column, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_improvisedb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_improvisedb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_improvisedb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_improvisedb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_improvisedb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_improvisedb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_improvisedb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_improvisedb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_parse_row_changematerialdb(char *split[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_parse_row_changematerialdb_pre ) {
+		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_changematerialdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_parse_row_changematerialdb_pre[hIndex].func;
+			retVal___ = preHookFunc(split, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.parse_row_changematerialdb(split, columns, current);
+	}
+	if( HPMHooks.count.HP_skill_parse_row_changematerialdb_post ) {
+		bool (*postHookFunc) (bool retVal___, char *split[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_changematerialdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_parse_row_changematerialdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, split, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_usave_add(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_usave_add_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_usave_add_pre[hIndex].func;
+			preHookFunc(sd, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.usave_add(sd, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_usave_add_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_usave_add_post[hIndex].func;
+			postHookFunc(sd, &skill_id, &skill_lv);
+		}
+	}
+	return;
+}
+void HP_skill_usave_trigger(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_usave_trigger_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_trigger_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_usave_trigger_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.usave_trigger(sd);
+	}
+	if( HPMHooks.count.HP_skill_usave_trigger_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_trigger_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_usave_trigger_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_skill_cooldown_load(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_cooldown_load_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_load_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_cooldown_load_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.cooldown_load(sd);
+	}
+	if( HPMHooks.count.HP_skill_cooldown_load_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_load_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_cooldown_load_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_skill_spellbook(struct map_session_data *sd, int nameid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_spellbook_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_spellbook_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_spellbook_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.spellbook(sd, nameid);
+	}
+	if( HPMHooks.count.HP_skill_spellbook_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_spellbook_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_spellbook_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_block_check(struct block_list *bl, enum sc_type type, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_block_check_pre ) {
+		int (*preHookFunc) (struct block_list *bl, enum sc_type *type, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_block_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_block_check_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.block_check(bl, type, skill_id);
+	}
+	if( HPMHooks.count.HP_skill_block_check_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type *type, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_block_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_block_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_detonator(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_detonator_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_detonator_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_detonator_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.detonator(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_detonator_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_detonator_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_detonator_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+bool HP_skill_check_camouflage(struct block_list *bl, struct status_change_entry *sce) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_skill_check_camouflage_pre ) {
+		bool (*preHookFunc) (struct block_list *bl, struct status_change_entry *sce);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_camouflage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_check_camouflage_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sce);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.check_camouflage(bl, sce);
+	}
+	if( HPMHooks.count.HP_skill_check_camouflage_post ) {
+		bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct status_change_entry *sce);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_camouflage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_check_camouflage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sce);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_magicdecoy(struct map_session_data *sd, int nameid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_magicdecoy_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magicdecoy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_magicdecoy_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.magicdecoy(sd, nameid);
+	}
+	if( HPMHooks.count.HP_skill_magicdecoy_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magicdecoy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_magicdecoy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_poisoningweapon(struct map_session_data *sd, int nameid) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_poisoningweapon_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_poisoningweapon_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_poisoningweapon_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.poisoningweapon(sd, nameid);
+	}
+	if( HPMHooks.count.HP_skill_poisoningweapon_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_poisoningweapon_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_poisoningweapon_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_select_menu(struct map_session_data *sd, uint16 skill_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_select_menu_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_select_menu_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_select_menu_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.select_menu(sd, skill_id);
+	}
+	if( HPMHooks.count.HP_skill_select_menu_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_select_menu_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_select_menu_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_elementalanalysis(struct map_session_data *sd, int n, uint16 skill_lv, unsigned short *item_list) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_elementalanalysis_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, uint16 *skill_lv, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_elementalanalysis_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_elementalanalysis_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, &skill_lv, item_list);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.elementalanalysis(sd, n, skill_lv, item_list);
+	}
+	if( HPMHooks.count.HP_skill_elementalanalysis_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, uint16 *skill_lv, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_elementalanalysis_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_elementalanalysis_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, &skill_lv, item_list);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_changematerial(struct map_session_data *sd, int n, unsigned short *item_list) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_changematerial_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_changematerial_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_changematerial_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, item_list);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.changematerial(sd, n, item_list);
+	}
+	if( HPMHooks.count.HP_skill_changematerial_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, unsigned short *item_list);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_changematerial_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_changematerial_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, item_list);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_elemental_type(uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_elemental_type_pre ) {
+		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_elemental_type_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_elemental_type_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_elemental_type(skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_skill_get_elemental_type_post ) {
+		int (*postHookFunc) (int retVal___, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_elemental_type_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_elemental_type_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+void HP_skill_cooldown_save(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_cooldown_save_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_save_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_cooldown_save_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.cooldown_save(sd);
+	}
+	if( HPMHooks.count.HP_skill_cooldown_save_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_save_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_cooldown_save_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_skill_maelstrom_suction(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_maelstrom_suction_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_maelstrom_suction_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_skill_maelstrom_suction_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.skill.maelstrom_suction(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_skill_maelstrom_suction_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_maelstrom_suction_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_skill_maelstrom_suction_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_skill_get_new_group_id(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_skill_get_new_group_id_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_new_group_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_get_new_group_id_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.skill.get_new_group_id();
+	}
+	if( HPMHooks.count.HP_skill_get_new_group_id_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_new_group_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_get_new_group_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+/* status */
+int HP_status_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.init();
+	}
+	if( HPMHooks.count.HP_status_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_status_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.final();
+	}
+	if( HPMHooks.count.HP_status_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_status_get_refine_chance(enum refine_type wlv, int refine) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_refine_chance_pre ) {
+		int (*preHookFunc) (enum refine_type *wlv, int *refine);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_refine_chance_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_refine_chance_pre[hIndex].func;
+			retVal___ = preHookFunc(&wlv, &refine);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_refine_chance(wlv, refine);
+	}
+	if( HPMHooks.count.HP_status_get_refine_chance_post ) {
+		int (*postHookFunc) (int retVal___, enum refine_type *wlv, int *refine);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_refine_chance_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_refine_chance_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &wlv, &refine);
+		}
+	}
+	return retVal___;
+}
+sc_type HP_status_skill2sc(int skill_id) {
+	int hIndex = 0;
+	sc_type retVal___;
+	memset(&retVal___, '\0', sizeof(sc_type));
+	if( HPMHooks.count.HP_status_skill2sc_pre ) {
+		sc_type (*preHookFunc) (int *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_skill2sc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_skill2sc_pre[hIndex].func;
+			retVal___ = preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.skill2sc(skill_id);
+	}
+	if( HPMHooks.count.HP_status_skill2sc_post ) {
+		sc_type (*postHookFunc) (sc_type retVal___, int *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_skill2sc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_skill2sc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &skill_id);
+		}
+	}
+	return retVal___;
+}
+int HP_status_sc2skill(sc_type sc) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_sc2skill_pre ) {
+		int (*preHookFunc) (sc_type *sc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2skill_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_sc2skill_pre[hIndex].func;
+			retVal___ = preHookFunc(&sc);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.sc2skill(sc);
+	}
+	if( HPMHooks.count.HP_status_sc2skill_post ) {
+		int (*postHookFunc) (int retVal___, sc_type *sc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2skill_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_sc2skill_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &sc);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_status_sc2scb_flag(sc_type sc) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_status_sc2scb_flag_pre ) {
+		unsigned int (*preHookFunc) (sc_type *sc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2scb_flag_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_sc2scb_flag_pre[hIndex].func;
+			retVal___ = preHookFunc(&sc);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.sc2scb_flag(sc);
+	}
+	if( HPMHooks.count.HP_status_sc2scb_flag_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, sc_type *sc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2scb_flag_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_sc2scb_flag_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &sc);
+		}
+	}
+	return retVal___;
+}
+int HP_status_type2relevant_bl_types(int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_type2relevant_bl_types_pre ) {
+		int (*preHookFunc) (int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_type2relevant_bl_types_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_type2relevant_bl_types_pre[hIndex].func;
+			retVal___ = preHookFunc(&type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.type2relevant_bl_types(type);
+	}
+	if( HPMHooks.count.HP_status_type2relevant_bl_types_post ) {
+		int (*postHookFunc) (int retVal___, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_type2relevant_bl_types_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_type2relevant_bl_types_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_sc_type(sc_type idx) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_sc_type_pre ) {
+		int (*preHookFunc) (sc_type *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_type_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_sc_type_pre[hIndex].func;
+			retVal___ = preHookFunc(&idx);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_sc_type(idx);
+	}
+	if( HPMHooks.count.HP_status_get_sc_type_post ) {
+		int (*postHookFunc) (int retVal___, sc_type *idx);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_type_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_sc_type_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &idx);
+		}
+	}
+	return retVal___;
+}
+int HP_status_damage(struct block_list *src, struct block_list *target, int64 hp, int64 sp, int walkdelay, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_damage_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, int64 *hp, int64 *sp, int *walkdelay, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_damage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_damage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &hp, &sp, &walkdelay, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.damage(src, target, hp, sp, walkdelay, flag);
+	}
+	if( HPMHooks.count.HP_status_damage_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int64 *hp, int64 *sp, int *walkdelay, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_damage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_damage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &hp, &sp, &walkdelay, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_charge(struct block_list *bl, int64 hp, int64 sp) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_charge_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int64 *hp, int64 *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_charge_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_charge_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &hp, &sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.charge(bl, hp, sp);
+	}
+	if( HPMHooks.count.HP_status_charge_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int64 *hp, int64 *sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_charge_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_charge_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &hp, &sp);
+		}
+	}
+	return retVal___;
+}
+int HP_status_percent_change(struct block_list *src, struct block_list *target, signed char hp_rate, signed char sp_rate, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_percent_change_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, signed char *hp_rate, signed char *sp_rate, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_percent_change_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_percent_change_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &hp_rate, &sp_rate, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.percent_change(src, target, hp_rate, sp_rate, flag);
+	}
+	if( HPMHooks.count.HP_status_percent_change_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, signed char *hp_rate, signed char *sp_rate, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_percent_change_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_percent_change_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &hp_rate, &sp_rate, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_set_hp(struct block_list *bl, unsigned int hp, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_set_hp_pre ) {
+		int (*preHookFunc) (struct block_list *bl, unsigned int *hp, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_hp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_set_hp_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &hp, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.set_hp(bl, hp, flag);
+	}
+	if( HPMHooks.count.HP_status_set_hp_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int *hp, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_hp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_set_hp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &hp, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_set_sp(struct block_list *bl, unsigned int sp, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_set_sp_pre ) {
+		int (*preHookFunc) (struct block_list *bl, unsigned int *sp, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_set_sp_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &sp, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.set_sp(bl, sp, flag);
+	}
+	if( HPMHooks.count.HP_status_set_sp_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int *sp, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_set_sp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &sp, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_heal(struct block_list *bl, int64 hp, int64 sp, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_heal_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int64 *hp, int64 *sp, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_heal_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_heal_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &hp, &sp, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.heal(bl, hp, sp, flag);
+	}
+	if( HPMHooks.count.HP_status_heal_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int64 *hp, int64 *sp, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_heal_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_heal_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &hp, &sp, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_revive(struct block_list *bl, unsigned char per_hp, unsigned char per_sp) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_revive_pre ) {
+		int (*preHookFunc) (struct block_list *bl, unsigned char *per_hp, unsigned char *per_sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_revive_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_revive_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &per_hp, &per_sp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.revive(bl, per_hp, per_sp);
+	}
+	if( HPMHooks.count.HP_status_revive_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned char *per_hp, unsigned char *per_sp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_revive_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_revive_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &per_hp, &per_sp);
+		}
+	}
+	return retVal___;
+}
+struct regen_data* HP_status_get_regen_data(struct block_list *bl) {
+	int hIndex = 0;
+	struct regen_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_status_get_regen_data_pre ) {
+		struct regen_data* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_regen_data_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_regen_data_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_regen_data(bl);
+	}
+	if( HPMHooks.count.HP_status_get_regen_data_post ) {
+		struct regen_data* (*postHookFunc) (struct regen_data* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_regen_data_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_regen_data_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+struct status_data* HP_status_get_status_data(struct block_list *bl) {
+	int hIndex = 0;
+	struct status_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_status_get_status_data_pre ) {
+		struct status_data* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_status_data_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_status_data_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_status_data(bl);
+	}
+	if( HPMHooks.count.HP_status_get_status_data_post ) {
+		struct status_data* (*postHookFunc) (struct status_data* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_status_data_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_status_data_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+struct status_data* HP_status_get_base_status(struct block_list *bl) {
+	int hIndex = 0;
+	struct status_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_status_get_base_status_pre ) {
+		struct status_data* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_status_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_base_status_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_base_status(bl);
+	}
+	if( HPMHooks.count.HP_status_get_base_status_post ) {
+		struct status_data* (*postHookFunc) (struct status_data* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_status_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_base_status_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+const char* HP_status_get_name(struct block_list *bl) {
+	int hIndex = 0;
+	const char* retVal___ = NULL;
+	if( HPMHooks.count.HP_status_get_name_pre ) {
+		const char* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_name_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_name_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_name(bl);
+	}
+	if( HPMHooks.count.HP_status_get_name_post ) {
+		const char* (*postHookFunc) (const char* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_name_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_name_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_class(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_class_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_class_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_class_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_class(bl);
+	}
+	if( HPMHooks.count.HP_status_get_class_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_class_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_class_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_lv(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_lv_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_lv_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_lv_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_lv(bl);
+	}
+	if( HPMHooks.count.HP_status_get_lv_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_lv_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_lv_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+defType HP_status_get_def(struct block_list *bl) {
+	int hIndex = 0;
+	defType retVal___;
+	memset(&retVal___, '\0', sizeof(defType));
+	if( HPMHooks.count.HP_status_get_def_pre ) {
+		defType (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_def_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_def_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_def(bl);
+	}
+	if( HPMHooks.count.HP_status_get_def_post ) {
+		defType (*postHookFunc) (defType retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_def_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_def_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_get_speed(struct block_list *bl) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_get_speed_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_speed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_speed_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_speed(bl);
+	}
+	if( HPMHooks.count.HP_status_get_speed_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_speed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_speed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+unsigned char HP_status_calc_attack_element(struct block_list *bl, struct status_change *sc, int element) {
+	int hIndex = 0;
+	unsigned char retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned char));
+	if( HPMHooks.count.HP_status_calc_attack_element_pre ) {
+		unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *element);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_attack_element_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_attack_element_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &element);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_attack_element(bl, sc, element);
+	}
+	if( HPMHooks.count.HP_status_calc_attack_element_post ) {
+		unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int *element);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_attack_element_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_attack_element_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &element);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_party_id(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_party_id_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_party_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_party_id_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_party_id(bl);
+	}
+	if( HPMHooks.count.HP_status_get_party_id_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_party_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_party_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_guild_id(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_guild_id_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_guild_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_guild_id_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_guild_id(bl);
+	}
+	if( HPMHooks.count.HP_status_get_guild_id_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_guild_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_guild_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_emblem_id(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_emblem_id_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_emblem_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_emblem_id_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_emblem_id(bl);
+	}
+	if( HPMHooks.count.HP_status_get_emblem_id_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_emblem_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_emblem_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_mexp(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_mexp_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_mexp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_mexp_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_mexp(bl);
+	}
+	if( HPMHooks.count.HP_status_get_mexp_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_mexp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_mexp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_race2(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_race2_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_race2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_race2_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_race2(bl);
+	}
+	if( HPMHooks.count.HP_status_get_race2_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_race2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_race2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+struct view_data* HP_status_get_viewdata(struct block_list *bl) {
+	int hIndex = 0;
+	struct view_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_status_get_viewdata_pre ) {
+		struct view_data* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_viewdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_viewdata_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_viewdata(bl);
+	}
+	if( HPMHooks.count.HP_status_get_viewdata_post ) {
+		struct view_data* (*postHookFunc) (struct view_data* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_viewdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_viewdata_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+void HP_status_set_viewdata(struct block_list *bl, int class_) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_set_viewdata_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_viewdata_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_set_viewdata_pre[hIndex].func;
+			preHookFunc(bl, &class_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.set_viewdata(bl, class_);
+	}
+	if( HPMHooks.count.HP_status_set_viewdata_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *class_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_viewdata_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_set_viewdata_post[hIndex].func;
+			postHookFunc(bl, &class_);
+		}
+	}
+	return;
+}
+void HP_status_change_init(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_change_init_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_change_init_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.change_init(bl);
+	}
+	if( HPMHooks.count.HP_status_change_init_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_change_init_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+struct status_change* HP_status_get_sc(struct block_list *bl) {
+	int hIndex = 0;
+	struct status_change* retVal___ = NULL;
+	if( HPMHooks.count.HP_status_get_sc_pre ) {
+		struct status_change* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_sc_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_sc(bl);
+	}
+	if( HPMHooks.count.HP_status_get_sc_post ) {
+		struct status_change* (*postHookFunc) (struct status_change* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_sc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_isdead(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_isdead_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isdead_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_isdead_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.isdead(bl);
+	}
+	if( HPMHooks.count.HP_status_isdead_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isdead_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_isdead_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_isimmune(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_isimmune_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isimmune_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_isimmune_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.isimmune(bl);
+	}
+	if( HPMHooks.count.HP_status_isimmune_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isimmune_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_isimmune_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_sc_def(struct block_list *bl, enum sc_type type, int rate, int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_sc_def_pre ) {
+		int (*preHookFunc) (struct block_list *bl, enum sc_type *type, int *rate, int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_def_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_sc_def_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type, &rate, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_sc_def(bl, type, rate, tick, flag);
+	}
+	if( HPMHooks.count.HP_status_get_sc_def_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type *type, int *rate, int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_def_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_sc_def_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type, &rate, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_change_start(struct block_list *bl, enum sc_type type, int rate, int val1, int val2, int val3, int val4, int tick, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_change_start_pre ) {
+		int (*preHookFunc) (struct block_list *bl, enum sc_type *type, int *rate, int *val1, int *val2, int *val3, int *val4, int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_start_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_change_start_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type, &rate, &val1, &val2, &val3, &val4, &tick, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.change_start(bl, type, rate, val1, val2, val3, val4, tick, flag);
+	}
+	if( HPMHooks.count.HP_status_change_start_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type *type, int *rate, int *val1, int *val2, int *val3, int *val4, int *tick, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_start_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_change_start_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type, &rate, &val1, &val2, &val3, &val4, &tick, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_change_end_(struct block_list *bl, enum sc_type type, int tid, const char *file, int line) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_change_end__pre ) {
+		int (*preHookFunc) (struct block_list *bl, enum sc_type *type, int *tid, const char *file, int *line);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_end__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_change_end__pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type, &tid, file, &line);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.change_end_(bl, type, tid, file, line);
+	}
+	if( HPMHooks.count.HP_status_change_end__post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type *type, int *tid, const char *file, int *line);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_end__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_change_end__post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type, &tid, file, &line);
+		}
+	}
+	return retVal___;
+}
+int HP_status_kaahi_heal_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_kaahi_heal_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_kaahi_heal_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_kaahi_heal_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.kaahi_heal_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_status_kaahi_heal_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_kaahi_heal_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_kaahi_heal_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_status_change_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_change_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_change_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.change_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_status_change_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_change_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_status_change_timer_sub(struct block_list *bl, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_change_timer_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_timer_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_status_change_timer_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.status.change_timer_sub(bl, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_status_change_timer_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_timer_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_status_change_timer_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_status_change_clear(struct block_list *bl, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_change_clear_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_change_clear_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.change_clear(bl, type);
+	}
+	if( HPMHooks.count.HP_status_change_clear_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_change_clear_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_status_change_clear_buffs(struct block_list *bl, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_change_clear_buffs_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_buffs_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_change_clear_buffs_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.change_clear_buffs(bl, type);
+	}
+	if( HPMHooks.count.HP_status_change_clear_buffs_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_buffs_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_change_clear_buffs_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_status_calc_bl_(struct block_list *bl, enum scb_flag flag, bool first) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_calc_bl__pre ) {
+		void (*preHookFunc) (struct block_list *bl, enum scb_flag *flag, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_bl__pre[hIndex].func;
+			preHookFunc(bl, &flag, &first);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.calc_bl_(bl, flag, first);
+	}
+	if( HPMHooks.count.HP_status_calc_bl__post ) {
+		void (*postHookFunc) (struct block_list *bl, enum scb_flag *flag, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_bl__post[hIndex].func;
+			postHookFunc(bl, &flag, &first);
+		}
+	}
+	return;
+}
+int HP_status_calc_mob_(struct mob_data *md, bool first) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_calc_mob__pre ) {
+		int (*preHookFunc) (struct mob_data *md, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mob__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_mob__pre[hIndex].func;
+			retVal___ = preHookFunc(md, &first);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_mob_(md, first);
+	}
+	if( HPMHooks.count.HP_status_calc_mob__post ) {
+		int (*postHookFunc) (int retVal___, struct mob_data *md, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mob__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_mob__post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &first);
+		}
+	}
+	return retVal___;
+}
+int HP_status_calc_pet_(struct pet_data *pd, bool first) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_calc_pet__pre ) {
+		int (*preHookFunc) (struct pet_data *pd, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pet__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_pet__pre[hIndex].func;
+			retVal___ = preHookFunc(pd, &first);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_pet_(pd, first);
+	}
+	if( HPMHooks.count.HP_status_calc_pet__post ) {
+		int (*postHookFunc) (int retVal___, struct pet_data *pd, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pet__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_pet__post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, pd, &first);
+		}
+	}
+	return retVal___;
+}
+int HP_status_calc_pc_(struct map_session_data *sd, bool first) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_calc_pc__pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_pc__pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &first);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_pc_(sd, first);
+	}
+	if( HPMHooks.count.HP_status_calc_pc__post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_pc__post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &first);
+		}
+	}
+	return retVal___;
+}
+int HP_status_calc_homunculus_(struct homun_data *hd, bool first) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_calc_homunculus__pre ) {
+		int (*preHookFunc) (struct homun_data *hd, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_homunculus__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_homunculus__pre[hIndex].func;
+			retVal___ = preHookFunc(hd, &first);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_homunculus_(hd, first);
+	}
+	if( HPMHooks.count.HP_status_calc_homunculus__post ) {
+		int (*postHookFunc) (int retVal___, struct homun_data *hd, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_homunculus__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_homunculus__post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, hd, &first);
+		}
+	}
+	return retVal___;
+}
+int HP_status_calc_mercenary_(struct mercenary_data *md, bool first) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_calc_mercenary__pre ) {
+		int (*preHookFunc) (struct mercenary_data *md, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mercenary__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_mercenary__pre[hIndex].func;
+			retVal___ = preHookFunc(md, &first);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_mercenary_(md, first);
+	}
+	if( HPMHooks.count.HP_status_calc_mercenary__post ) {
+		int (*postHookFunc) (int retVal___, struct mercenary_data *md, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mercenary__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_mercenary__post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, md, &first);
+		}
+	}
+	return retVal___;
+}
+int HP_status_calc_elemental_(struct elemental_data *ed, bool first) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_calc_elemental__pre ) {
+		int (*preHookFunc) (struct elemental_data *ed, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_elemental__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_elemental__pre[hIndex].func;
+			retVal___ = preHookFunc(ed, &first);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_elemental_(ed, first);
+	}
+	if( HPMHooks.count.HP_status_calc_elemental__post ) {
+		int (*postHookFunc) (int retVal___, struct elemental_data *ed, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_elemental__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_elemental__post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ed, &first);
+		}
+	}
+	return retVal___;
+}
+void HP_status_calc_misc(struct block_list *bl, struct status_data *status, int level) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_calc_misc_pre ) {
+		void (*preHookFunc) (struct block_list *bl, struct status_data *status, int *level);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_misc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_misc_pre[hIndex].func;
+			preHookFunc(bl, status, &level);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.calc_misc(bl, status, level);
+	}
+	if( HPMHooks.count.HP_status_calc_misc_post ) {
+		void (*postHookFunc) (struct block_list *bl, struct status_data *status, int *level);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_misc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_misc_post[hIndex].func;
+			postHookFunc(bl, status, &level);
+		}
+	}
+	return;
+}
+void HP_status_calc_regen(struct block_list *bl, struct status_data *st, struct regen_data *regen) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_calc_regen_pre ) {
+		void (*preHookFunc) (struct block_list *bl, struct status_data *st, struct regen_data *regen);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_regen_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_regen_pre[hIndex].func;
+			preHookFunc(bl, st, regen);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.calc_regen(bl, st, regen);
+	}
+	if( HPMHooks.count.HP_status_calc_regen_post ) {
+		void (*postHookFunc) (struct block_list *bl, struct status_data *st, struct regen_data *regen);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_regen_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_regen_post[hIndex].func;
+			postHookFunc(bl, st, regen);
+		}
+	}
+	return;
+}
+void HP_status_calc_regen_rate(struct block_list *bl, struct regen_data *regen, struct status_change *sc) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_calc_regen_rate_pre ) {
+		void (*preHookFunc) (struct block_list *bl, struct regen_data *regen, struct status_change *sc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_regen_rate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_regen_rate_pre[hIndex].func;
+			preHookFunc(bl, regen, sc);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.calc_regen_rate(bl, regen, sc);
+	}
+	if( HPMHooks.count.HP_status_calc_regen_rate_post ) {
+		void (*postHookFunc) (struct block_list *bl, struct regen_data *regen, struct status_change *sc);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_regen_rate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_regen_rate_post[hIndex].func;
+			postHookFunc(bl, regen, sc);
+		}
+	}
+	return;
+}
+int HP_status_check_skilluse(struct block_list *src, struct block_list *target, uint16 skill_id, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_check_skilluse_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_skilluse_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_check_skilluse_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &skill_id, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.check_skilluse(src, target, skill_id, flag);
+	}
+	if( HPMHooks.count.HP_status_check_skilluse_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 *skill_id, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_skilluse_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_check_skilluse_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &skill_id, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_check_visibility(struct block_list *src, struct block_list *target) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_check_visibility_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_visibility_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_check_visibility_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.check_visibility(src, target);
+	}
+	if( HPMHooks.count.HP_status_check_visibility_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_visibility_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_check_visibility_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target);
+		}
+	}
+	return retVal___;
+}
+int HP_status_change_spread(struct block_list *src, struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_change_spread_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_spread_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_change_spread_pre[hIndex].func;
+			retVal___ = preHookFunc(src, bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.change_spread(src, bl);
+	}
+	if( HPMHooks.count.HP_status_change_spread_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_spread_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_change_spread_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, bl);
+		}
+	}
+	return retVal___;
+}
+defType HP_status_calc_def(struct block_list *bl, struct status_change *sc, int def, bool viewable) {
+	int hIndex = 0;
+	defType retVal___;
+	memset(&retVal___, '\0', sizeof(defType));
+	if( HPMHooks.count.HP_status_calc_def_pre ) {
+		defType (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *def, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_def_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &def, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_def(bl, sc, def, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_def_post ) {
+		defType (*postHookFunc) (defType retVal___, struct block_list *bl, struct status_change *sc, int *def, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_def_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &def, &viewable);
+		}
+	}
+	return retVal___;
+}
+short HP_status_calc_def2(struct block_list *bl, struct status_change *sc, int def2, bool viewable) {
+	int hIndex = 0;
+	short retVal___;
+	memset(&retVal___, '\0', sizeof(short));
+	if( HPMHooks.count.HP_status_calc_def2_pre ) {
+		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *def2, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_def2_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &def2, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_def2(bl, sc, def2, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_def2_post ) {
+		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int *def2, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_def2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &def2, &viewable);
+		}
+	}
+	return retVal___;
+}
+defType HP_status_calc_mdef(struct block_list *bl, struct status_change *sc, int mdef, bool viewable) {
+	int hIndex = 0;
+	defType retVal___;
+	memset(&retVal___, '\0', sizeof(defType));
+	if( HPMHooks.count.HP_status_calc_mdef_pre ) {
+		defType (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *mdef, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_mdef_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &mdef, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_mdef(bl, sc, mdef, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_mdef_post ) {
+		defType (*postHookFunc) (defType retVal___, struct block_list *bl, struct status_change *sc, int *mdef, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_mdef_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &mdef, &viewable);
+		}
+	}
+	return retVal___;
+}
+short HP_status_calc_mdef2(struct block_list *bl, struct status_change *sc, int mdef2, bool viewable) {
+	int hIndex = 0;
+	short retVal___;
+	memset(&retVal___, '\0', sizeof(short));
+	if( HPMHooks.count.HP_status_calc_mdef2_pre ) {
+		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *mdef2, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_mdef2_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &mdef2, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_mdef2(bl, sc, mdef2, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_mdef2_post ) {
+		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int *mdef2, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_mdef2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &mdef2, &viewable);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_batk(struct block_list *bl, struct status_change *sc, int batk, bool viewable) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_batk_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *batk, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_batk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_batk_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &batk, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_batk(bl, sc, batk, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_batk_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *batk, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_batk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_batk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &batk, &viewable);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_total_mdef(struct block_list *src) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_total_mdef_pre ) {
+		int (*preHookFunc) (struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_total_mdef_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_total_mdef_pre[hIndex].func;
+			retVal___ = preHookFunc(src);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_total_mdef(src);
+	}
+	if( HPMHooks.count.HP_status_get_total_mdef_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_total_mdef_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_total_mdef_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_total_def(struct block_list *src) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_total_def_pre ) {
+		int (*preHookFunc) (struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_total_def_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_total_def_pre[hIndex].func;
+			retVal___ = preHookFunc(src);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_total_def(src);
+	}
+	if( HPMHooks.count.HP_status_get_total_def_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_total_def_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_total_def_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src);
+		}
+	}
+	return retVal___;
+}
+int HP_status_get_matk(struct block_list *src, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_get_matk_pre ) {
+		int (*preHookFunc) (struct block_list *src, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_matk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_get_matk_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.get_matk(src, flag);
+	}
+	if( HPMHooks.count.HP_status_get_matk_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_matk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_get_matk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_status_readdb(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_readdb_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_readdb_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.readdb();
+	}
+	if( HPMHooks.count.HP_status_readdb_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_readdb_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+void HP_status_initChangeTables(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_initChangeTables_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initChangeTables_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_initChangeTables_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.initChangeTables();
+	}
+	if( HPMHooks.count.HP_status_initChangeTables_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initChangeTables_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_initChangeTables_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_status_initDummyData(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_initDummyData_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initDummyData_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_initDummyData_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.initDummyData();
+	}
+	if( HPMHooks.count.HP_status_initDummyData_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initDummyData_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_initDummyData_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_status_base_amotion_pc(struct map_session_data *sd, struct status_data *st) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_base_amotion_pc_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct status_data *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_amotion_pc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_base_amotion_pc_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.base_amotion_pc(sd, st);
+	}
+	if( HPMHooks.count.HP_status_base_amotion_pc_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct status_data *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_amotion_pc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_base_amotion_pc_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, st);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_base_atk(const struct block_list *bl, const struct status_data *st) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_base_atk_pre ) {
+		unsigned short (*preHookFunc) (const struct block_list *bl, const struct status_data *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_atk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_base_atk_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.base_atk(bl, st);
+	}
+	if( HPMHooks.count.HP_status_base_atk_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, const struct block_list *bl, const struct status_data *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_atk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_base_atk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, st);
+		}
+	}
+	return retVal___;
+}
+void HP_status_calc_sigma(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_calc_sigma_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_sigma_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_sigma_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.calc_sigma();
+	}
+	if( HPMHooks.count.HP_status_calc_sigma_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_sigma_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_sigma_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+unsigned int HP_status_base_pc_maxhp(struct map_session_data *sd, struct status_data *st) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_status_base_pc_maxhp_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd, struct status_data *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_pc_maxhp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_base_pc_maxhp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.base_pc_maxhp(sd, st);
+	}
+	if( HPMHooks.count.HP_status_base_pc_maxhp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd, struct status_data *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_pc_maxhp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_base_pc_maxhp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, st);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_status_base_pc_maxsp(struct map_session_data *sd, struct status_data *st) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_status_base_pc_maxsp_pre ) {
+		unsigned int (*preHookFunc) (struct map_session_data *sd, struct status_data *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_pc_maxsp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_base_pc_maxsp_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, st);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.base_pc_maxsp(sd, st);
+	}
+	if( HPMHooks.count.HP_status_base_pc_maxsp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd, struct status_data *st);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_pc_maxsp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_base_pc_maxsp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, st);
+		}
+	}
+	return retVal___;
+}
+int HP_status_calc_npc_(struct npc_data *nd, bool first) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_calc_npc__pre ) {
+		int (*preHookFunc) (struct npc_data *nd, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_npc__pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_npc__pre[hIndex].func;
+			retVal___ = preHookFunc(nd, &first);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_npc_(nd, first);
+	}
+	if( HPMHooks.count.HP_status_calc_npc__post ) {
+		int (*postHookFunc) (int retVal___, struct npc_data *nd, bool *first);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_npc__post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_npc__post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, nd, &first);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_str(struct block_list *bl, struct status_change *sc, int str) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_str_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_str_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_str_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &str);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_str(bl, sc, str);
+	}
+	if( HPMHooks.count.HP_status_calc_str_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *str);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_str_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_str_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &str);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_agi(struct block_list *bl, struct status_change *sc, int agi) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_agi_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *agi);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_agi_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_agi_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &agi);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_agi(bl, sc, agi);
+	}
+	if( HPMHooks.count.HP_status_calc_agi_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *agi);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_agi_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_agi_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &agi);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_vit(struct block_list *bl, struct status_change *sc, int vit) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_vit_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *vit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_vit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_vit_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &vit);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_vit(bl, sc, vit);
+	}
+	if( HPMHooks.count.HP_status_calc_vit_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *vit);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_vit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_vit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &vit);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_int(struct block_list *bl, struct status_change *sc, int int_) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_int_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *int_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_int_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_int_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &int_);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_int(bl, sc, int_);
+	}
+	if( HPMHooks.count.HP_status_calc_int_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *int_);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_int_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_int_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &int_);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_dex(struct block_list *bl, struct status_change *sc, int dex) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_dex_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *dex);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dex_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_dex_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &dex);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_dex(bl, sc, dex);
+	}
+	if( HPMHooks.count.HP_status_calc_dex_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *dex);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dex_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_dex_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &dex);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_luk(struct block_list *bl, struct status_change *sc, int luk) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_luk_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *luk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_luk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_luk_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &luk);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_luk(bl, sc, luk);
+	}
+	if( HPMHooks.count.HP_status_calc_luk_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *luk);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_luk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_luk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &luk);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_watk(struct block_list *bl, struct status_change *sc, int watk, bool viewable) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_watk_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *watk, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_watk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_watk_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &watk, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_watk(bl, sc, watk, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_watk_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *watk, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_watk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_watk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &watk, &viewable);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_matk(struct block_list *bl, struct status_change *sc, int matk, bool viewable) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_matk_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *matk, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_matk_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_matk_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &matk, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_matk(bl, sc, matk, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_matk_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *matk, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_matk_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_matk_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &matk, &viewable);
+		}
+	}
+	return retVal___;
+}
+signed short HP_status_calc_hit(struct block_list *bl, struct status_change *sc, int hit, bool viewable) {
+	int hIndex = 0;
+	signed short retVal___;
+	memset(&retVal___, '\0', sizeof(signed short));
+	if( HPMHooks.count.HP_status_calc_hit_pre ) {
+		signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *hit, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_hit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_hit_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &hit, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_hit(bl, sc, hit, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_hit_post ) {
+		signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int *hit, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_hit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_hit_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &hit, &viewable);
+		}
+	}
+	return retVal___;
+}
+signed short HP_status_calc_critical(struct block_list *bl, struct status_change *sc, int critical, bool viewable) {
+	int hIndex = 0;
+	signed short retVal___;
+	memset(&retVal___, '\0', sizeof(signed short));
+	if( HPMHooks.count.HP_status_calc_critical_pre ) {
+		signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *critical, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_critical_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_critical_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &critical, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_critical(bl, sc, critical, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_critical_post ) {
+		signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int *critical, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_critical_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_critical_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &critical, &viewable);
+		}
+	}
+	return retVal___;
+}
+signed short HP_status_calc_flee(struct block_list *bl, struct status_change *sc, int flee, bool viewable) {
+	int hIndex = 0;
+	signed short retVal___;
+	memset(&retVal___, '\0', sizeof(signed short));
+	if( HPMHooks.count.HP_status_calc_flee_pre ) {
+		signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *flee, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_flee_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &flee, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_flee(bl, sc, flee, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_flee_post ) {
+		signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int *flee, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_flee_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &flee, &viewable);
+		}
+	}
+	return retVal___;
+}
+signed short HP_status_calc_flee2(struct block_list *bl, struct status_change *sc, int flee2, bool viewable) {
+	int hIndex = 0;
+	signed short retVal___;
+	memset(&retVal___, '\0', sizeof(signed short));
+	if( HPMHooks.count.HP_status_calc_flee2_pre ) {
+		signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *flee2, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_flee2_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &flee2, &viewable);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_flee2(bl, sc, flee2, viewable);
+	}
+	if( HPMHooks.count.HP_status_calc_flee2_post ) {
+		signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int *flee2, bool *viewable);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_flee2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &flee2, &viewable);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_speed(struct block_list *bl, struct status_change *sc, int speed) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_speed_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *speed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_speed_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_speed_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &speed);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_speed(bl, sc, speed);
+	}
+	if( HPMHooks.count.HP_status_calc_speed_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *speed);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_speed_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_speed_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &speed);
+		}
+	}
+	return retVal___;
+}
+short HP_status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, int aspd_rate) {
+	int hIndex = 0;
+	short retVal___;
+	memset(&retVal___, '\0', sizeof(short));
+	if( HPMHooks.count.HP_status_calc_aspd_rate_pre ) {
+		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *aspd_rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_rate_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_aspd_rate_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &aspd_rate);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_aspd_rate(bl, sc, aspd_rate);
+	}
+	if( HPMHooks.count.HP_status_calc_aspd_rate_post ) {
+		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int *aspd_rate);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_rate_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_aspd_rate_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &aspd_rate);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_dmotion(struct block_list *bl, struct status_change *sc, int dmotion) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_dmotion_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *dmotion);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dmotion_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_dmotion_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &dmotion);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_dmotion(bl, sc, dmotion);
+	}
+	if( HPMHooks.count.HP_status_calc_dmotion_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *dmotion);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dmotion_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_dmotion_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &dmotion);
+		}
+	}
+	return retVal___;
+}
+short HP_status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int aspd) {
+	int hIndex = 0;
+	short retVal___;
+	memset(&retVal___, '\0', sizeof(short));
+	if( HPMHooks.count.HP_status_calc_fix_aspd_pre ) {
+		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *aspd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_fix_aspd_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_fix_aspd_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &aspd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_fix_aspd(bl, sc, aspd);
+	}
+	if( HPMHooks.count.HP_status_calc_fix_aspd_post ) {
+		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int *aspd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_fix_aspd_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_fix_aspd_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &aspd);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_status_calc_maxhp(struct block_list *bl, struct status_change *sc, uint64 maxhp) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_status_calc_maxhp_pre ) {
+		unsigned int (*preHookFunc) (struct block_list *bl, struct status_change *sc, uint64 *maxhp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxhp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_maxhp_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &maxhp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_maxhp(bl, sc, maxhp);
+	}
+	if( HPMHooks.count.HP_status_calc_maxhp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, uint64 *maxhp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxhp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_maxhp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &maxhp);
+		}
+	}
+	return retVal___;
+}
+unsigned int HP_status_calc_maxsp(struct block_list *bl, struct status_change *sc, unsigned int maxsp) {
+	int hIndex = 0;
+	unsigned int retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned int));
+	if( HPMHooks.count.HP_status_calc_maxsp_pre ) {
+		unsigned int (*preHookFunc) (struct block_list *bl, struct status_change *sc, unsigned int *maxsp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxsp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_maxsp_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &maxsp);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_maxsp(bl, sc, maxsp);
+	}
+	if( HPMHooks.count.HP_status_calc_maxsp_post ) {
+		unsigned int (*postHookFunc) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, unsigned int *maxsp);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxsp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_maxsp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &maxsp);
+		}
+	}
+	return retVal___;
+}
+unsigned char HP_status_calc_element(struct block_list *bl, struct status_change *sc, int element) {
+	int hIndex = 0;
+	unsigned char retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned char));
+	if( HPMHooks.count.HP_status_calc_element_pre ) {
+		unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *element);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_element_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &element);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_element(bl, sc, element);
+	}
+	if( HPMHooks.count.HP_status_calc_element_post ) {
+		unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int *element);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_element_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &element);
+		}
+	}
+	return retVal___;
+}
+unsigned char HP_status_calc_element_lv(struct block_list *bl, struct status_change *sc, int lv) {
+	int hIndex = 0;
+	unsigned char retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned char));
+	if( HPMHooks.count.HP_status_calc_element_lv_pre ) {
+		unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_lv_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_element_lv_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_element_lv(bl, sc, lv);
+	}
+	if( HPMHooks.count.HP_status_calc_element_lv_post ) {
+		unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int *lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_lv_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_element_lv_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &lv);
+		}
+	}
+	return retVal___;
+}
+unsigned short HP_status_calc_mode(struct block_list *bl, struct status_change *sc, int mode) {
+	int hIndex = 0;
+	unsigned short retVal___;
+	memset(&retVal___, '\0', sizeof(unsigned short));
+	if( HPMHooks.count.HP_status_calc_mode_pre ) {
+		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *mode);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mode_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_mode_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sc, &mode);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.calc_mode(bl, sc, mode);
+	}
+	if( HPMHooks.count.HP_status_calc_mode_post ) {
+		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int *mode);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mode_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_mode_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sc, &mode);
+		}
+	}
+	return retVal___;
+}
+void HP_status_calc_bl_main(struct block_list *bl, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_calc_bl_main_pre ) {
+		void (*preHookFunc) (struct block_list *bl, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl_main_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_calc_bl_main_pre[hIndex].func;
+			preHookFunc(bl, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.calc_bl_main(bl, flag);
+	}
+	if( HPMHooks.count.HP_status_calc_bl_main_post ) {
+		void (*postHookFunc) (struct block_list *bl, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl_main_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_calc_bl_main_post[hIndex].func;
+			postHookFunc(bl, &flag);
+		}
+	}
+	return;
+}
+void HP_status_display_add(struct map_session_data *sd, enum sc_type type, int dval1, int dval2, int dval3) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_display_add_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, enum sc_type *type, int *dval1, int *dval2, int *dval3);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_display_add_pre[hIndex].func;
+			preHookFunc(sd, &type, &dval1, &dval2, &dval3);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.display_add(sd, type, dval1, dval2, dval3);
+	}
+	if( HPMHooks.count.HP_status_display_add_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, enum sc_type *type, int *dval1, int *dval2, int *dval3);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_display_add_post[hIndex].func;
+			postHookFunc(sd, &type, &dval1, &dval2, &dval3);
+		}
+	}
+	return;
+}
+void HP_status_display_remove(struct map_session_data *sd, enum sc_type type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_status_display_remove_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, enum sc_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_remove_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_display_remove_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.status.display_remove(sd, type);
+	}
+	if( HPMHooks.count.HP_status_display_remove_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, enum sc_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_remove_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_display_remove_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+int HP_status_natural_heal(struct block_list *bl, va_list args) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_natural_heal_pre ) {
+		int (*preHookFunc) (struct block_list *bl, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_natural_heal_pre; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			preHookFunc = HPMHooks.list.HP_status_natural_heal_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, args___copy);
+			va_end(args___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list args___copy; va_copy(args___copy, args);
+		retVal___ = HPMHooks.source.status.natural_heal(bl, args___copy);
+		va_end(args___copy);
+	}
+	if( HPMHooks.count.HP_status_natural_heal_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list args);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_natural_heal_post; hIndex++ ) {
+			va_list args___copy; va_copy(args___copy, args);
+			postHookFunc = HPMHooks.list.HP_status_natural_heal_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, args___copy);
+			va_end(args___copy);
+		}
+	}
+	return retVal___;
+}
+int HP_status_natural_heal_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_status_natural_heal_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_natural_heal_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_natural_heal_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.natural_heal_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_status_natural_heal_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_natural_heal_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_natural_heal_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+bool HP_status_readdb_job1(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_status_readdb_job1_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_job1_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_readdb_job1_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.readdb_job1(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_status_readdb_job1_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_job1_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_readdb_job1_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_status_readdb_job2(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_status_readdb_job2_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_job2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_readdb_job2_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.readdb_job2(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_status_readdb_job2_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_job2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_readdb_job2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_status_readdb_sizefix(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_status_readdb_sizefix_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_sizefix_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_readdb_sizefix_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.readdb_sizefix(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_status_readdb_sizefix_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_sizefix_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_readdb_sizefix_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_status_readdb_refine(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_status_readdb_refine_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_refine_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_readdb_refine_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.readdb_refine(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_status_readdb_refine_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_refine_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_readdb_refine_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+bool HP_status_readdb_scconfig(char *fields[], int columns, int current) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_status_readdb_scconfig_pre ) {
+		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_scconfig_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_status_readdb_scconfig_pre[hIndex].func;
+			retVal___ = preHookFunc(fields, &columns, &current);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.status.readdb_scconfig(fields, columns, current);
+	}
+	if( HPMHooks.count.HP_status_readdb_scconfig_post ) {
+		bool (*postHookFunc) (bool retVal___, char *fields[], int *columns, int *current);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_scconfig_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_status_readdb_scconfig_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, fields, &columns, &current);
+		}
+	}
+	return retVal___;
+}
+/* storage */
+void HP_storage_reconnect(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_storage_reconnect_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_reconnect_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.storage.reconnect();
+	}
+	if( HPMHooks.count.HP_storage_reconnect_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_reconnect_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+int HP_storage_delitem(struct map_session_data *sd, int n, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_delitem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_delitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_delitem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &n, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.storage.delitem(sd, n, amount);
+	}
+	if( HPMHooks.count.HP_storage_delitem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *n, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_delitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_delitem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &n, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_storage_open(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_open_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_open_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_open_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.storage.open(sd);
+	}
+	if( HPMHooks.count.HP_storage_open_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_open_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_open_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_storage_add(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_add_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_add_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_add_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.storage.add(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_storage_add_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_add_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_add_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_storage_get(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_get_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_get_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_get_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.storage.get(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_storage_get_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_get_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_get_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_storage_additem(struct map_session_data *sd, struct item *item_data, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_additem_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct item *item_data, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_additem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_additem_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, item_data, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.storage.additem(sd, item_data, amount);
+	}
+	if( HPMHooks.count.HP_storage_additem_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_additem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_additem_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, item_data, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_storage_addfromcart(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_addfromcart_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_addfromcart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_addfromcart_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.storage.addfromcart(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_storage_addfromcart_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_addfromcart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_addfromcart_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index, &amount);
+		}
+	}
+	return retVal___;
+}
+int HP_storage_gettocart(struct map_session_data *sd, int index, int amount) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_gettocart_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_gettocart_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_gettocart_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.storage.gettocart(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_storage_gettocart_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int *index, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_gettocart_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_gettocart_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &index, &amount);
+		}
+	}
+	return retVal___;
+}
+void HP_storage_close(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_storage_close_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_close_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.storage.close(sd);
+	}
+	if( HPMHooks.count.HP_storage_close_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_close_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_storage_pc_quit(struct map_session_data *sd, int flag) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_storage_pc_quit_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_pc_quit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_pc_quit_pre[hIndex].func;
+			preHookFunc(sd, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.storage.pc_quit(sd, flag);
+	}
+	if( HPMHooks.count.HP_storage_pc_quit_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_pc_quit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_pc_quit_post[hIndex].func;
+			postHookFunc(sd, &flag);
+		}
+	}
+	return;
+}
+int HP_storage_comp_item(const void *_i1, const void *_i2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_comp_item_pre ) {
+		int (*preHookFunc) (const void *_i1, const void *_i2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_comp_item_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_comp_item_pre[hIndex].func;
+			retVal___ = preHookFunc(_i1, _i2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.storage.comp_item(_i1, _i2);
+	}
+	if( HPMHooks.count.HP_storage_comp_item_post ) {
+		int (*postHookFunc) (int retVal___, const void *_i1, const void *_i2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_comp_item_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_comp_item_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, _i1, _i2);
+		}
+	}
+	return retVal___;
+}
+void HP_storage_sortitem(struct item *items, unsigned int size) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_storage_sortitem_pre ) {
+		void (*preHookFunc) (struct item *items, unsigned int *size);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_sortitem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_storage_sortitem_pre[hIndex].func;
+			preHookFunc(items, &size);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.storage.sortitem(items, size);
+	}
+	if( HPMHooks.count.HP_storage_sortitem_post ) {
+		void (*postHookFunc) (struct item *items, unsigned int *size);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_sortitem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_storage_sortitem_post[hIndex].func;
+			postHookFunc(items, &size);
+		}
+	}
+	return;
+}
+int HP_storage_reconnect_sub(DBKey key, DBData *data, va_list ap) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_storage_reconnect_sub_pre ) {
+		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_sub_pre; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			preHookFunc = HPMHooks.list.HP_storage_reconnect_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&key, data, ap___copy);
+			va_end(ap___copy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		va_list ap___copy; va_copy(ap___copy, ap);
+		retVal___ = HPMHooks.source.storage.reconnect_sub(key, data, ap___copy);
+		va_end(ap___copy);
+	}
+	if( HPMHooks.count.HP_storage_reconnect_sub_post ) {
+		int (*postHookFunc) (int retVal___, DBKey *key, DBData *data, va_list ap);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_sub_post; hIndex++ ) {
+			va_list ap___copy; va_copy(ap___copy, ap);
+			postHookFunc = HPMHooks.list.HP_storage_reconnect_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &key, data, ap___copy);
+			va_end(ap___copy);
+		}
+	}
+	return retVal___;
+}
+/* trade */
+void HP_trade_request(struct map_session_data *sd, struct map_session_data *target_sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_trade_request_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *target_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_request_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_request_pre[hIndex].func;
+			preHookFunc(sd, target_sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.trade.request(sd, target_sd);
+	}
+	if( HPMHooks.count.HP_trade_request_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *target_sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_request_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_request_post[hIndex].func;
+			postHookFunc(sd, target_sd);
+		}
+	}
+	return;
+}
+void HP_trade_ack(struct map_session_data *sd, int type) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_trade_ack_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_ack_pre[hIndex].func;
+			preHookFunc(sd, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.trade.ack(sd, type);
+	}
+	if( HPMHooks.count.HP_trade_ack_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_ack_post[hIndex].func;
+			postHookFunc(sd, &type);
+		}
+	}
+	return;
+}
+int HP_trade_check_impossible(struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_trade_check_impossible_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_impossible_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_check_impossible_pre[hIndex].func;
+			retVal___ = preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.trade.check_impossible(sd);
+	}
+	if( HPMHooks.count.HP_trade_check_impossible_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_impossible_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_check_impossible_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_trade_check(struct map_session_data *sd, struct map_session_data *tsd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_trade_check_pre ) {
+		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_check_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, tsd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.trade.check(sd, tsd);
+	}
+	if( HPMHooks.count.HP_trade_check_post ) {
+		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_check_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, tsd);
+		}
+	}
+	return retVal___;
+}
+void HP_trade_additem(struct map_session_data *sd, short index, short amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_trade_additem_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, short *index, short *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_additem_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_additem_pre[hIndex].func;
+			preHookFunc(sd, &index, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.trade.additem(sd, index, amount);
+	}
+	if( HPMHooks.count.HP_trade_additem_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, short *index, short *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_additem_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_additem_post[hIndex].func;
+			postHookFunc(sd, &index, &amount);
+		}
+	}
+	return;
+}
+void HP_trade_addzeny(struct map_session_data *sd, int amount) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_trade_addzeny_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_addzeny_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_addzeny_pre[hIndex].func;
+			preHookFunc(sd, &amount);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.trade.addzeny(sd, amount);
+	}
+	if( HPMHooks.count.HP_trade_addzeny_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *amount);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_addzeny_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_addzeny_post[hIndex].func;
+			postHookFunc(sd, &amount);
+		}
+	}
+	return;
+}
+void HP_trade_ok(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_trade_ok_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ok_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_ok_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.trade.ok(sd);
+	}
+	if( HPMHooks.count.HP_trade_ok_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ok_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_ok_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_trade_cancel(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_trade_cancel_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_cancel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_cancel_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.trade.cancel(sd);
+	}
+	if( HPMHooks.count.HP_trade_cancel_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_cancel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_cancel_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_trade_commit(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_trade_commit_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_commit_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_trade_commit_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.trade.commit(sd);
+	}
+	if( HPMHooks.count.HP_trade_commit_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_commit_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_trade_commit_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+/* unit */
+int HP_unit_init(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_init_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_init_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.init();
+	}
+	if( HPMHooks.count.HP_unit_init_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_init_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_final(void) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_final_pre ) {
+		int (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_final_pre[hIndex].func;
+			retVal___ = preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.final();
+	}
+	if( HPMHooks.count.HP_unit_final_post ) {
+		int (*postHookFunc) (int retVal___);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_final_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___);
+		}
+	}
+	return retVal___;
+}
+struct unit_data* HP_unit_bl2ud(struct block_list *bl) {
+	int hIndex = 0;
+	struct unit_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_unit_bl2ud_pre ) {
+		struct unit_data* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_bl2ud_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.bl2ud(bl);
+	}
+	if( HPMHooks.count.HP_unit_bl2ud_post ) {
+		struct unit_data* (*postHookFunc) (struct unit_data* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_bl2ud_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+struct unit_data* HP_unit_bl2ud2(struct block_list *bl) {
+	int hIndex = 0;
+	struct unit_data* retVal___ = NULL;
+	if( HPMHooks.count.HP_unit_bl2ud2_pre ) {
+		struct unit_data* (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_bl2ud2_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.bl2ud2(bl);
+	}
+	if( HPMHooks.count.HP_unit_bl2ud2_post ) {
+		struct unit_data* (*postHookFunc) (struct unit_data* retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_bl2ud2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_attack_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_attack_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_attack_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.attack_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_unit_attack_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_attack_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_walktoxy_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_walktoxy_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.walktoxy_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_unit_walktoxy_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_walktoxy_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_walktoxy_sub(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_walktoxy_sub_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_walktoxy_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.walktoxy_sub(bl);
+	}
+	if( HPMHooks.count.HP_unit_walktoxy_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_walktoxy_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_delay_walktoxy_timer(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_delay_walktoxy_timer_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_delay_walktoxy_timer_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_delay_walktoxy_timer_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.delay_walktoxy_timer(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_unit_delay_walktoxy_timer_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_delay_walktoxy_timer_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_delay_walktoxy_timer_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_walktoxy(struct block_list *bl, short x, short y, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_walktoxy_pre ) {
+		int (*preHookFunc) (struct block_list *bl, short *x, short *y, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_walktoxy_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &x, &y, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.walktoxy(bl, x, y, flag);
+	}
+	if( HPMHooks.count.HP_unit_walktoxy_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, short *x, short *y, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_walktoxy_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &x, &y, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_walktobl_sub(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_walktobl_sub_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_walktobl_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.walktobl_sub(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_unit_walktobl_sub_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_walktobl_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_walktobl_pre ) {
+		int (*preHookFunc) (struct block_list *bl, struct block_list *tbl, int *range, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_walktobl_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, tbl, &range, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.walktobl(bl, tbl, range, flag);
+	}
+	if( HPMHooks.count.HP_unit_walktobl_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, struct block_list *tbl, int *range, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_walktobl_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, tbl, &range, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_run(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_run_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_run_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.run(bl);
+	}
+	if( HPMHooks.count.HP_unit_run_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_run_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_wugdash(struct block_list *bl, struct map_session_data *sd) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_wugdash_pre ) {
+		int (*preHookFunc) (struct block_list *bl, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_wugdash_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_wugdash_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.wugdash(bl, sd);
+	}
+	if( HPMHooks.count.HP_unit_wugdash_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_wugdash_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_wugdash_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, sd);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_escape(struct block_list *bl, struct block_list *target, short dist) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_escape_pre ) {
+		int (*preHookFunc) (struct block_list *bl, struct block_list *target, short *dist);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_escape_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_escape_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, target, &dist);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.escape(bl, target, dist);
+	}
+	if( HPMHooks.count.HP_unit_escape_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, struct block_list *target, short *dist);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_escape_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_escape_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, target, &dist);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, bool checkpath) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_movepos_pre ) {
+		int (*preHookFunc) (struct block_list *bl, short *dst_x, short *dst_y, int *easy, bool *checkpath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_movepos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_movepos_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &dst_x, &dst_y, &easy, &checkpath);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.movepos(bl, dst_x, dst_y, easy, checkpath);
+	}
+	if( HPMHooks.count.HP_unit_movepos_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, short *dst_x, short *dst_y, int *easy, bool *checkpath);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_movepos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_movepos_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &dst_x, &dst_y, &easy, &checkpath);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_setdir(struct block_list *bl, unsigned char dir) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_setdir_pre ) {
+		int (*preHookFunc) (struct block_list *bl, unsigned char *dir);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_setdir_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_setdir_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &dir);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.setdir(bl, dir);
+	}
+	if( HPMHooks.count.HP_unit_setdir_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned char *dir);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_setdir_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_setdir_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &dir);
+		}
+	}
+	return retVal___;
+}
+uint8 HP_unit_getdir(struct block_list *bl) {
+	int hIndex = 0;
+	uint8 retVal___;
+	memset(&retVal___, '\0', sizeof(uint8));
+	if( HPMHooks.count.HP_unit_getdir_pre ) {
+		uint8 (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_getdir_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_getdir_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.getdir(bl);
+	}
+	if( HPMHooks.count.HP_unit_getdir_post ) {
+		uint8 (*postHookFunc) (uint8 retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_getdir_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_getdir_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_blown(struct block_list *bl, int dx, int dy, int count, int flag) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_blown_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *dx, int *dy, int *count, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_blown_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_blown_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &dx, &dy, &count, &flag);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.blown(bl, dx, dy, count, flag);
+	}
+	if( HPMHooks.count.HP_unit_blown_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *dx, int *dy, int *count, int *flag);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_blown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_blown_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &dx, &dy, &count, &flag);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_warp(struct block_list *bl, short m, short x, short y, clr_type type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_warp_pre ) {
+		int (*preHookFunc) (struct block_list *bl, short *m, short *x, short *y, clr_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_warp_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_warp_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &m, &x, &y, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.warp(bl, m, x, y, type);
+	}
+	if( HPMHooks.count.HP_unit_warp_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, short *m, short *x, short *y, clr_type *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_warp_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_warp_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &m, &x, &y, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_stop_walking(struct block_list *bl, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_stop_walking_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_walking_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_stop_walking_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.stop_walking(bl, type);
+	}
+	if( HPMHooks.count.HP_unit_stop_walking_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_walking_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_stop_walking_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_skilluse_id_pre ) {
+		int (*preHookFunc) (struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_skilluse_id_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &target_id, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.skilluse_id(src, target_id, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_unit_skilluse_id_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_skilluse_id_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &target_id, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_is_walking(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_is_walking_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_is_walking_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_is_walking_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.is_walking(bl);
+	}
+	if( HPMHooks.count.HP_unit_is_walking_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_is_walking_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_is_walking_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_can_move(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_can_move_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_move_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_can_move_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.can_move(bl);
+	}
+	if( HPMHooks.count.HP_unit_can_move_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_move_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_can_move_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_resume_running(int tid, unsigned int tick, int id, intptr_t data) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_resume_running_pre ) {
+		int (*preHookFunc) (int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_resume_running_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_resume_running_pre[hIndex].func;
+			retVal___ = preHookFunc(&tid, &tick, &id, &data);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.resume_running(tid, tick, id, data);
+	}
+	if( HPMHooks.count.HP_unit_resume_running_post ) {
+		int (*postHookFunc) (int retVal___, int *tid, unsigned int *tick, int *id, intptr_t *data);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_resume_running_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_resume_running_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, &tid, &tick, &id, &data);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_set_walkdelay(struct block_list *bl, unsigned int tick, int delay, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_set_walkdelay_pre ) {
+		int (*preHookFunc) (struct block_list *bl, unsigned int *tick, int *delay, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_walkdelay_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_set_walkdelay_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &tick, &delay, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.set_walkdelay(bl, tick, delay, type);
+	}
+	if( HPMHooks.count.HP_unit_set_walkdelay_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int *tick, int *delay, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_walkdelay_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_set_walkdelay_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &tick, &delay, &type);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_skilluse_id2_pre ) {
+		int (*preHookFunc) (struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_skilluse_id2_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &target_id, &skill_id, &skill_lv, &casttime, &castcancel);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.skilluse_id2(src, target_id, skill_id, skill_lv, casttime, castcancel);
+	}
+	if( HPMHooks.count.HP_unit_skilluse_id2_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_skilluse_id2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &target_id, &skill_id, &skill_lv, &casttime, &castcancel);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_skilluse_pos_pre ) {
+		int (*preHookFunc) (struct block_list *src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_skilluse_pos_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &skill_x, &skill_y, &skill_id, &skill_lv);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.skilluse_pos(src, skill_x, skill_y, skill_id, skill_lv);
+	}
+	if( HPMHooks.count.HP_unit_skilluse_pos_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_skilluse_pos_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &skill_x, &skill_y, &skill_id, &skill_lv);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_skilluse_pos2(struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_skilluse_pos2_pre ) {
+		int (*preHookFunc) (struct block_list *src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos2_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_skilluse_pos2_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &skill_x, &skill_y, &skill_id, &skill_lv, &casttime, &castcancel);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.skilluse_pos2(src, skill_x, skill_y, skill_id, skill_lv, casttime, castcancel);
+	}
+	if( HPMHooks.count.HP_unit_skilluse_pos2_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, short *skill_x, short *skill_y, uint16 *skill_id, uint16 *skill_lv, int *casttime, int *castcancel);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos2_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_skilluse_pos2_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &skill_x, &skill_y, &skill_id, &skill_lv, &casttime, &castcancel);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_set_target(struct unit_data *ud, int target_id) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_set_target_pre ) {
+		int (*preHookFunc) (struct unit_data *ud, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_target_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_set_target_pre[hIndex].func;
+			retVal___ = preHookFunc(ud, &target_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.set_target(ud, target_id);
+	}
+	if( HPMHooks.count.HP_unit_set_target_post ) {
+		int (*postHookFunc) (int retVal___, struct unit_data *ud, int *target_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_target_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_set_target_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, ud, &target_id);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_stop_attack(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_stop_attack_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_attack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_stop_attack_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.stop_attack(bl);
+	}
+	if( HPMHooks.count.HP_unit_stop_attack_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_attack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_stop_attack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_unattackable(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_unattackable_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_unattackable_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_unattackable_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.unattackable(bl);
+	}
+	if( HPMHooks.count.HP_unit_unattackable_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_unattackable_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_unattackable_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_attack(struct block_list *src, int target_id, int continuous) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_attack_pre ) {
+		int (*preHookFunc) (struct block_list *src, int *target_id, int *continuous);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_attack_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &target_id, &continuous);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.attack(src, target_id, continuous);
+	}
+	if( HPMHooks.count.HP_unit_attack_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, int *target_id, int *continuous);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_attack_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &target_id, &continuous);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_cancel_combo(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_cancel_combo_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_cancel_combo_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_cancel_combo_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.cancel_combo(bl);
+	}
+	if( HPMHooks.count.HP_unit_cancel_combo_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_cancel_combo_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_cancel_combo_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+bool HP_unit_can_reach_pos(struct block_list *bl, int x, int y, int easy) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_unit_can_reach_pos_pre ) {
+		bool (*preHookFunc) (struct block_list *bl, int *x, int *y, int *easy);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_pos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_can_reach_pos_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &x, &y, &easy);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.can_reach_pos(bl, x, y, easy);
+	}
+	if( HPMHooks.count.HP_unit_can_reach_pos_post ) {
+		bool (*postHookFunc) (bool retVal___, struct block_list *bl, int *x, int *y, int *easy);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_pos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_can_reach_pos_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &x, &y, &easy);
+		}
+	}
+	return retVal___;
+}
+bool HP_unit_can_reach_bl(struct block_list *bl, struct block_list *tbl, int range, int easy, short *x, short *y) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_unit_can_reach_bl_pre ) {
+		bool (*preHookFunc) (struct block_list *bl, struct block_list *tbl, int *range, int *easy, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_bl_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_can_reach_bl_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, tbl, &range, &easy, x, y);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.can_reach_bl(bl, tbl, range, easy, x, y);
+	}
+	if( HPMHooks.count.HP_unit_can_reach_bl_post ) {
+		bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct block_list *tbl, int *range, int *easy, short *x, short *y);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_bl_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_can_reach_bl_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, tbl, &range, &easy, x, y);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_calc_pos_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *tx, int *ty, uint8 *dir);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_calc_pos_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_calc_pos_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &tx, &ty, &dir);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.calc_pos(bl, tx, ty, dir);
+	}
+	if( HPMHooks.count.HP_unit_calc_pos_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *tx, int *ty, uint8 *dir);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_calc_pos_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_calc_pos_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &tx, &ty, &dir);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_attack_timer_sub(struct block_list *src, int tid, unsigned int tick) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_attack_timer_sub_pre ) {
+		int (*preHookFunc) (struct block_list *src, int *tid, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_sub_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_attack_timer_sub_pre[hIndex].func;
+			retVal___ = preHookFunc(src, &tid, &tick);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.attack_timer_sub(src, tid, tick);
+	}
+	if( HPMHooks.count.HP_unit_attack_timer_sub_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, int *tid, unsigned int *tick);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_sub_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_attack_timer_sub_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, &tid, &tick);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_skillcastcancel(struct block_list *bl, int type) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_skillcastcancel_pre ) {
+		int (*preHookFunc) (struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skillcastcancel_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_skillcastcancel_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &type);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.skillcastcancel(bl, type);
+	}
+	if( HPMHooks.count.HP_unit_skillcastcancel_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, int *type);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skillcastcancel_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_skillcastcancel_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &type);
+		}
+	}
+	return retVal___;
+}
+void HP_unit_dataset(struct block_list *bl) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_unit_dataset_pre ) {
+		void (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_dataset_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_dataset_pre[hIndex].func;
+			preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.unit.dataset(bl);
+	}
+	if( HPMHooks.count.HP_unit_dataset_post ) {
+		void (*postHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_dataset_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_dataset_post[hIndex].func;
+			postHookFunc(bl);
+		}
+	}
+	return;
+}
+int HP_unit_counttargeted(struct block_list *bl) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_counttargeted_pre ) {
+		int (*preHookFunc) (struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_counttargeted_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_counttargeted_pre[hIndex].func;
+			retVal___ = preHookFunc(bl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.counttargeted(bl);
+	}
+	if( HPMHooks.count.HP_unit_counttargeted_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_counttargeted_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_counttargeted_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_fixdamage(struct block_list *src, struct block_list *target, unsigned int tick, int sdelay, int ddelay, int64 damage, int div, int type, int64 damage2) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_fixdamage_pre ) {
+		int (*preHookFunc) (struct block_list *src, struct block_list *target, unsigned int *tick, int *sdelay, int *ddelay, int64 *damage, int *div, int *type, int64 *damage2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_fixdamage_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_fixdamage_pre[hIndex].func;
+			retVal___ = preHookFunc(src, target, &tick, &sdelay, &ddelay, &damage, &div, &type, &damage2);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.fixdamage(src, target, tick, sdelay, ddelay, damage, div, type, damage2);
+	}
+	if( HPMHooks.count.HP_unit_fixdamage_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, unsigned int *tick, int *sdelay, int *ddelay, int64 *damage, int *div, int *type, int64 *damage2);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_fixdamage_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_fixdamage_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, src, target, &tick, &sdelay, &ddelay, &damage, &div, &type, &damage2);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_changeviewsize(struct block_list *bl, short size) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_changeviewsize_pre ) {
+		int (*preHookFunc) (struct block_list *bl, short *size);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_changeviewsize_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_changeviewsize_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &size);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.changeviewsize(bl, size);
+	}
+	if( HPMHooks.count.HP_unit_changeviewsize_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, short *size);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_changeviewsize_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_changeviewsize_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &size);
+		}
+	}
+	return retVal___;
+}
+int HP_unit_remove_map(struct block_list *bl, clr_type clrtype, const char *file, int line, const char *func) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_remove_map_pre ) {
+		int (*preHookFunc) (struct block_list *bl, clr_type *clrtype, const char *file, int *line, const char *func);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_remove_map_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &clrtype, file, &line, func);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.remove_map(bl, clrtype, file, line, func);
+	}
+	if( HPMHooks.count.HP_unit_remove_map_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, clr_type *clrtype, const char *file, int *line, const char *func);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_remove_map_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &clrtype, file, &line, func);
+		}
+	}
+	return retVal___;
+}
+void HP_unit_remove_map_pc(struct map_session_data *sd, clr_type clrtype) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_unit_remove_map_pc_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, clr_type *clrtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_pc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_remove_map_pc_pre[hIndex].func;
+			preHookFunc(sd, &clrtype);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.unit.remove_map_pc(sd, clrtype);
+	}
+	if( HPMHooks.count.HP_unit_remove_map_pc_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, clr_type *clrtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_pc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_remove_map_pc_post[hIndex].func;
+			postHookFunc(sd, &clrtype);
+		}
+	}
+	return;
+}
+void HP_unit_free_pc(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_unit_free_pc_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_pc_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_free_pc_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.unit.free_pc(sd);
+	}
+	if( HPMHooks.count.HP_unit_free_pc_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_pc_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_free_pc_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+int HP_unit_free(struct block_list *bl, clr_type clrtype) {
+	int hIndex = 0;
+	int retVal___;
+	memset(&retVal___, '\0', sizeof(int));
+	if( HPMHooks.count.HP_unit_free_pre ) {
+		int (*preHookFunc) (struct block_list *bl, clr_type *clrtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_unit_free_pre[hIndex].func;
+			retVal___ = preHookFunc(bl, &clrtype);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.unit.free(bl, clrtype);
+	}
+	if( HPMHooks.count.HP_unit_free_post ) {
+		int (*postHookFunc) (int retVal___, struct block_list *bl, clr_type *clrtype);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_unit_free_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, bl, &clrtype);
+		}
+	}
+	return retVal___;
+}
+/* vending */
+void HP_vending_init(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_vending_init_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_init_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_vending_init_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.vending.init();
+	}
+	if( HPMHooks.count.HP_vending_init_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_init_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_vending_init_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_vending_final(void) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_vending_final_pre ) {
+		void (*preHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_final_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_vending_final_pre[hIndex].func;
+			preHookFunc();
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.vending.final();
+	}
+	if( HPMHooks.count.HP_vending_final_post ) {
+		void (*postHookFunc) (void);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_final_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_vending_final_post[hIndex].func;
+			postHookFunc();
+		}
+	}
+	return;
+}
+void HP_vending_close(struct map_session_data *sd) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_vending_close_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_close_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_vending_close_pre[hIndex].func;
+			preHookFunc(sd);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.vending.close(sd);
+	}
+	if( HPMHooks.count.HP_vending_close_post ) {
+		void (*postHookFunc) (struct map_session_data *sd);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_close_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_vending_close_post[hIndex].func;
+			postHookFunc(sd);
+		}
+	}
+	return;
+}
+void HP_vending_open(struct map_session_data *sd, const char *message, const uint8 *data, int count) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_vending_open_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, const char *message, const uint8 *data, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_open_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_vending_open_pre[hIndex].func;
+			preHookFunc(sd, message, data, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.vending.open(sd, message, data, count);
+	}
+	if( HPMHooks.count.HP_vending_open_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, const char *message, const uint8 *data, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_open_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_vending_open_post[hIndex].func;
+			postHookFunc(sd, message, data, &count);
+		}
+	}
+	return;
+}
+void HP_vending_list(struct map_session_data *sd, unsigned int id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_vending_list_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, unsigned int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_list_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_vending_list_pre[hIndex].func;
+			preHookFunc(sd, &id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.vending.list(sd, id);
+	}
+	if( HPMHooks.count.HP_vending_list_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, unsigned int *id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_list_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_vending_list_post[hIndex].func;
+			postHookFunc(sd, &id);
+		}
+	}
+	return;
+}
+void HP_vending_purchase(struct map_session_data *sd, int aid, unsigned int uid, const uint8 *data, int count) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_vending_purchase_pre ) {
+		void (*preHookFunc) (struct map_session_data *sd, int *aid, unsigned int *uid, const uint8 *data, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_purchase_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_vending_purchase_pre[hIndex].func;
+			preHookFunc(sd, &aid, &uid, data, &count);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.vending.purchase(sd, aid, uid, data, count);
+	}
+	if( HPMHooks.count.HP_vending_purchase_post ) {
+		void (*postHookFunc) (struct map_session_data *sd, int *aid, unsigned int *uid, const uint8 *data, int *count);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_purchase_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_vending_purchase_post[hIndex].func;
+			postHookFunc(sd, &aid, &uid, data, &count);
+		}
+	}
+	return;
+}
+bool HP_vending_search(struct map_session_data *sd, unsigned short nameid) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_vending_search_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_search_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_vending_search_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, &nameid);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.vending.search(sd, nameid);
+	}
+	if( HPMHooks.count.HP_vending_search_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned short *nameid);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_search_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_vending_search_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, &nameid);
+		}
+	}
+	return retVal___;
+}
+bool HP_vending_searchall(struct map_session_data *sd, const struct s_search_store_search *s) {
+	int hIndex = 0;
+	bool retVal___;
+	memset(&retVal___, '\0', sizeof(bool));
+	if( HPMHooks.count.HP_vending_searchall_pre ) {
+		bool (*preHookFunc) (struct map_session_data *sd, const struct s_search_store_search *s);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_searchall_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_vending_searchall_pre[hIndex].func;
+			retVal___ = preHookFunc(sd, s);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return retVal___;
+		}
+	}
+	{
+		retVal___ = HPMHooks.source.vending.searchall(sd, s);
+	}
+	if( HPMHooks.count.HP_vending_searchall_post ) {
+		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const struct s_search_store_search *s);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_searchall_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_vending_searchall_post[hIndex].func;
+			retVal___ = postHookFunc(retVal___, sd, s);
+		}
+	}
+	return retVal___;
+}
diff --git a/src/plugins/HPMHooking/HPMHooking.sources.inc b/src/plugins/HPMHooking/HPMHooking.sources.inc
new file mode 100644
index 000000000..89a668e0c
--- /dev/null
+++ b/src/plugins/HPMHooking/HPMHooking.sources.inc
@@ -0,0 +1,37 @@
+memcpy(&HPMHooks.source.atcommand, atcommand, sizeof(struct atcommand_interface));
+memcpy(&HPMHooks.source.battle, battle, sizeof(struct battle_interface));
+memcpy(&HPMHooks.source.bg, bg, sizeof(struct battleground_interface));
+memcpy(&HPMHooks.source.buyingstore, buyingstore, sizeof(struct buyingstore_interface));
+memcpy(&HPMHooks.source.chat, chat, sizeof(struct chat_interface));
+memcpy(&HPMHooks.source.chrif, chrif, sizeof(struct chrif_interface));
+memcpy(&HPMHooks.source.clif, clif, sizeof(struct clif_interface));
+memcpy(&HPMHooks.source.duel, duel, sizeof(struct duel_interface));
+memcpy(&HPMHooks.source.elemental, elemental, sizeof(struct elemental_interface));
+memcpy(&HPMHooks.source.guild, guild, sizeof(struct guild_interface));
+memcpy(&HPMHooks.source.gstorage, gstorage, sizeof(struct guild_storage_interface));
+memcpy(&HPMHooks.source.homun, homun, sizeof(struct homunculus_interface));
+memcpy(&HPMHooks.source.instance, instance, sizeof(struct instance_interface));
+memcpy(&HPMHooks.source.intif, intif, sizeof(struct intif_interface));
+memcpy(&HPMHooks.source.ircbot, ircbot, sizeof(struct irc_bot_interface));
+memcpy(&HPMHooks.source.itemdb, itemdb, sizeof(struct itemdb_interface));
+memcpy(&HPMHooks.source.logs, logs, sizeof(struct log_interface));
+memcpy(&HPMHooks.source.mail, mail, sizeof(struct mail_interface));
+memcpy(&HPMHooks.source.map, map, sizeof(struct map_interface));
+memcpy(&HPMHooks.source.mapit, mapit, sizeof(struct mapit_interface));
+memcpy(&HPMHooks.source.mapreg, mapreg, sizeof(struct mapreg_interface));
+memcpy(&HPMHooks.source.mercenary, mercenary, sizeof(struct mercenary_interface));
+memcpy(&HPMHooks.source.mob, mob, sizeof(struct mob_interface));
+memcpy(&HPMHooks.source.npc, npc, sizeof(struct npc_interface));
+memcpy(&HPMHooks.source.party, party, sizeof(struct party_interface));
+memcpy(&HPMHooks.source.path, path, sizeof(struct path_interface));
+memcpy(&HPMHooks.source.pc, pc, sizeof(struct pc_interface));
+memcpy(&HPMHooks.source.pet, pet, sizeof(struct pet_interface));
+memcpy(&HPMHooks.source.quest, quest, sizeof(struct quest_interface));
+memcpy(&HPMHooks.source.script, script, sizeof(struct script_interface));
+memcpy(&HPMHooks.source.searchstore, searchstore, sizeof(struct searchstore_interface));
+memcpy(&HPMHooks.source.skill, skill, sizeof(struct skill_interface));
+memcpy(&HPMHooks.source.status, status, sizeof(struct status_interface));
+memcpy(&HPMHooks.source.storage, storage, sizeof(struct storage_interface));
+memcpy(&HPMHooks.source.trade, trade, sizeof(struct trade_interface));
+memcpy(&HPMHooks.source.unit, unit, sizeof(struct unit_interface));
+memcpy(&HPMHooks.source.vending, vending, sizeof(struct vending_interface));
diff --git a/src/plugins/Makefile.in b/src/plugins/Makefile.in
index ff7d5b2e2..ed573238d 100644
--- a/src/plugins/Makefile.in
+++ b/src/plugins/Makefile.in
@@ -1,7 +1,26 @@
-
-COMMON_H = ../common/HPMi.h ../common/cbasetypes.h
-
-PLUGINS = sample db2sql
+################  PLUGIN CONFIGURATION  ##############################
+#                                                                    #
+# When you add a plugin, add its name here:                          #
+# Example: if you have a plugin named my_cool_plugin.c and another   #
+# one named my_second_plugin.c, add them to the list like this:      #
+#                                                                    #
+# MYPLUGINS = my_cool_plugin my_second_plugin                        #
+#                                                                    #
+# Note: DO NOT include the .c extension!!!                           #
+
+MYPLUGINS = 
+
+#                                                                    #
+#########  DO NOT EDIT ANYTHING BELOW THIS LINE!!!  ##################
+
+PLUGINS = sample db2sql HPMHooking $(MYPLUGINS)
+
+COMMON_H = $(shell ls ../common/*.h)
+CONFIG_H = $(shell ls ../config/*.h ../config/*/*.h)
+MAP_H = $(shell ls ../map/*.h)
+CHAR_H = $(shell ls ../char/*.h)
+LOGIN_H = $(shell ls ../login/*.h)
+ALL_H = $(COMMON_H) $(CONFIG_H) $(MAP_H) $(CHAR_H) $(LOGIN_H)
 
 @SET_MAKE@
 
@@ -9,17 +28,19 @@ CC = @CC@
 export CC
 
 #####################################################################
-.PHONY: all $(PLUGINS) sample db2sql clean help
+.PHONY: all $(PLUGINS) clean buildclean help
 
 all: $(PLUGINS) Makefile
 
-sample: sample@DLLEXT@
-
-db2sql: db2sql@DLLEXT@
+$(PLUGINS): %: ../../plugins/%@DLLEXT@
 
-clean:
-	@echo "	CLEAN	plugins"
+buildclean:
+	@echo "	CLEAN	plugins (build temp files)"
 	@rm -rf *.o
+	
+clean: buildclean
+	@echo "	CLEAN	plugins"
+	@rm -rf ../../plugins/*@DLLEXT@
 
 help:
 	@echo "possible targets are $(PLUGINS:%='%') 'all' 'clean' 'help'"
@@ -31,6 +52,8 @@ help:
 Makefile: Makefile.in
 	@$(MAKE) -C ../.. src/plugins/Makefile
 
-%@DLLEXT@: %.c $(COMMON_H)
+.SECONDEXPANSION:
+
+../../plugins/%@DLLEXT@: %.c $(ALL_H) $$(shell ls %/* 2>/dev/null)
 	@echo "	CC	$<"
-	@$(CC) @DEFS@ @CFLAGS@ @CPPFLAGS@ @LDFLAGS@ @SOFLAGS@ -o ../../plugins/$@ $<
+	@$(CC) @DEFS@ @CFLAGS@ @CPPFLAGS@ @LDFLAGS@ @SOFLAGS@ -o $@ $<
\ No newline at end of file
diff --git a/src/plugins/sample.c b/src/plugins/sample.c
index 4f9e34f74..d1a95c71d 100644
--- a/src/plugins/sample.c
+++ b/src/plugins/sample.c
@@ -88,6 +88,26 @@ void sample_packet0f3(int fd) {
 	
 	clif->pGlobalMessage(fd,sd);
 }
+int my_pc_dropitem_storage;/* storage var */
+/* my custom prehook for pc_dropitem, checks if amount of item being dropped is higher than 1 and if so cap it to 1 and store the value of how much it was */
+int my_pc_dropitem_pre(struct map_session_data *sd,int *n,int *amount) {
+	my_pc_dropitem_storage = 0;
+	if( *amount > 1 ) {
+		my_pc_dropitem_storage = *amount;
+		*amount = 1;
+	}
+	return 0;
+}
+/* postHook receive retVal as the first param, allows posthook to act accordingly to whatever the original was going to return */
+int my_pc_dropitem_post(int retVal, struct map_session_data *sd,int *n,int *amount) {
+	if( retVal != 1 ) return retVal;/* we don't do anything if pc_dropitem didn't return 1 (success) */
+	if( my_pc_dropitem_storage ) {/* signs whether pre-hook did this */
+		char output[99];
+		snprintf(output,99,"[ Warning ] you can only drop 1 item at a time, capped from %d to 1",my_pc_dropitem_storage);
+		clif->colormes(sd->fd,COLOR_RED,output);
+	}
+	return 1;
+}
 /* run when server starts */
 HPExport void plugin_init (void) {
 	char *server_type;
@@ -103,6 +123,7 @@ HPExport void plugin_init (void) {
 	/* map-server interfaces */
 	script = GET_SYMBOL("script");
 	clif = GET_SYMBOL("clif");
+	pc = GET_SYMBOL("pc");
 	
 	/* session[] */
 	session = GET_SYMBOL("session");
@@ -132,7 +153,16 @@ HPExport void plugin_init (void) {
 	if( HPMi->addPacket != NULL ) {//link our 'sample' packet to map-server
 		HPMi->addPacket(0xf3,-1,sample_packet0f3,hpClif_Parse,HPMi->pid);
 	}
-
+	
+	/* in this sample we add a PreHook to pc->dropitem */
+	/* to identify whether the item being dropped is on amount higher than 1 */
+	/* if so, it stores the amount on a variable (my_pc_dropitem_storage) and changes the amount to 1 */
+	addHookPre("pc->dropitem",my_pc_dropitem_pre);
+	/* in this sample we add a PostHook to pc->dropitem */
+	/* if the original pc->dropitem was successful and the amount stored on my_pc_dropitem_storage is higher than 1, */
+	/* our posthook will display a message to the user about the cap */
+	/* - by checking whether it was successful (retVal value) it allows for the originals conditions to take place */
+	addHookPost("pc->dropitem",my_pc_dropitem_post);	
 }
 /* run when server is ready (online) */
 HPExport void server_online (void) {