HPM Hooks Update

Signed-off-by: HerculesWSAPI <Hercules@efficiently.awesome>

1 files changed, 2518 insertions, 0 deletions

diff --git a/src/plugins/HPMHooking/HPMHooking.Hooks.inc b/src/plugins/HPMHooking/HPMHooking.Hooks.inc
index 23f00ea97..e563653a8 100644
--- a/src/plugins/HPMHooking/HPMHooking.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking.Hooks.inc
@@ -9,6 +9,7 @@ void HP_atcommand_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_atcommand_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -34,6 +35,7 @@ void HP_atcommand_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_atcommand_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_final_pre[hIndex].func;
 			preHookFunc();
@@ -60,6 +62,7 @@ bool HP_atcommand_exec(const int fd, struct map_session_data *sd, const char *me
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_atcommand_exec_pre ) {
 		bool (*preHookFunc) (const int *fd, struct map_session_data *sd, const char *message, bool *player_invoked);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exec_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_exec_pre[hIndex].func;
 			retVal___ = preHookFunc(&fd, sd, message, &player_invoked);
@@ -86,6 +89,7 @@ bool HP_atcommand_create(char *name, AtCommandFunc func) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_atcommand_create_pre ) {
 		bool (*preHookFunc) (char *name, AtCommandFunc *func);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_create_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_create_pre[hIndex].func;
 			retVal___ = preHookFunc(name, &func);
@@ -112,6 +116,7 @@ bool HP_atcommand_can_use(struct map_session_data *sd, const char *command) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_atcommand_can_use_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const char *command);
+		*HPMforce_return = false;
 		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);
@@ -138,6 +143,7 @@ bool HP_atcommand_can_use2(struct map_session_data *sd, const char *command, AtC
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_atcommand_can_use2_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const char *command, AtCommandType *type);
+		*HPMforce_return = false;
 		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);
@@ -163,6 +169,7 @@ void HP_atcommand_load_groups(GroupSettings **groups, config_setting_t **command
 	int hIndex = 0;
 	if( HPMHooks.count.HP_atcommand_load_groups_pre ) {
 		void (*preHookFunc) (GroupSettings **groups, config_setting_t **commands_, size_t *sz);
+		*HPMforce_return = false;
 		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);
@@ -189,6 +196,7 @@ AtCommandInfo* HP_atcommand_exists(const char *name) {
 	AtCommandInfo* retVal___ = NULL;
 	if( HPMHooks.count.HP_atcommand_exists_pre ) {
 		AtCommandInfo* (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exists_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_exists_pre[hIndex].func;
 			retVal___ = preHookFunc(name);
@@ -215,6 +223,7 @@ bool HP_atcommand_msg_read(const char *cfg_name, bool allow_override) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_atcommand_msg_read_pre ) {
 		bool (*preHookFunc) (const char *cfg_name, bool *allow_override);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_read_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_msg_read_pre[hIndex].func;
 			retVal___ = preHookFunc(cfg_name, &allow_override);
@@ -240,6 +249,7 @@ void HP_atcommand_final_msg(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_atcommand_final_msg_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_final_msg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_final_msg_pre[hIndex].func;
 			preHookFunc();
@@ -266,6 +276,7 @@ struct atcmd_binding_data* HP_atcommand_get_bind_byname(const char *name) {
 	struct atcmd_binding_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_atcommand_get_bind_byname_pre ) {
 		struct atcmd_binding_data* (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		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);
@@ -292,6 +303,7 @@ AtCommandInfo* HP_atcommand_get_info_byname(const char *name) {
 	AtCommandInfo* retVal___ = NULL;
 	if( HPMHooks.count.HP_atcommand_get_info_byname_pre ) {
 		AtCommandInfo* (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		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);
@@ -318,6 +330,7 @@ const char* HP_atcommand_check_alias(const char *aliasname) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_atcommand_check_alias_pre ) {
 		const char* (*preHookFunc) (const char *aliasname);
+		*HPMforce_return = false;
 		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);
@@ -343,6 +356,7 @@ void HP_atcommand_get_suggestions(struct map_session_data *sd, const char *name,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -368,6 +382,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -394,6 +409,7 @@ int HP_atcommand_stopattack(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_atcommand_stopattack_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -426,6 +442,7 @@ int HP_atcommand_pvpoff_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_atcommand_pvpoff_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -458,6 +475,7 @@ int HP_atcommand_pvpon_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_atcommand_pvpon_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -490,6 +508,7 @@ int HP_atcommand_atkillmonster_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_atcommand_atkillmonster_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -521,6 +540,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_raise_sub_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_raise_sub_pre[hIndex].func;
 			preHookFunc(sd);
@@ -546,6 +566,7 @@ void HP_atcommand_get_jail_time(int jailtime, int *year, int *month, int *day, i
 	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);
+		*HPMforce_return = false;
 		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);
@@ -572,6 +593,7 @@ int HP_atcommand_cleanfloor_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_atcommand_cleanfloor_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -604,6 +626,7 @@ int HP_atcommand_mutearea_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_atcommand_mutearea_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -635,6 +658,7 @@ void HP_atcommand_commands_sub(struct map_session_data *sd, const int fd, AtComm
 	int hIndex = 0;
 	if( HPMHooks.count.HP_atcommand_commands_sub_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, const int *fd, AtCommandType *type);
+		*HPMforce_return = false;
 		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);
@@ -660,6 +684,7 @@ void HP_atcommand_cmd_db_clear(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_atcommand_cmd_db_clear_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -686,6 +711,7 @@ int HP_atcommand_cmd_db_clear_sub(DBKey key, DBData *data, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_atcommand_cmd_db_clear_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -717,6 +743,7 @@ void HP_atcommand_doload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_atcommand_doload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_doload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_doload_pre[hIndex].func;
 			preHookFunc();
@@ -742,6 +769,7 @@ void HP_atcommand_base_commands(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_atcommand_base_commands_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_base_commands_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_base_commands_pre[hIndex].func;
 			preHookFunc();
@@ -768,6 +796,7 @@ bool HP_atcommand_add(char *name, AtCommandFunc func, bool replace) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_atcommand_add_pre ) {
 		bool (*preHookFunc) (char *name, AtCommandFunc *func, bool *replace);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_add_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_add_pre[hIndex].func;
 			retVal___ = preHookFunc(name, &func, &replace);
@@ -794,6 +823,7 @@ const char* HP_atcommand_msg(int msg_number) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_atcommand_msg_pre ) {
 		const char* (*preHookFunc) (int *msg_number);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_atcommand_msg_pre[hIndex].func;
 			retVal___ = preHookFunc(&msg_number);
@@ -820,6 +850,7 @@ void HP_battle_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_battle_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_battle_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -845,6 +876,7 @@ void HP_battle_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_battle_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_battle_final_pre[hIndex].func;
 			preHookFunc();
@@ -872,6 +904,7 @@ struct Damage HP_battle_calc_attack(int attack_type, struct block_list *bl, stru
 	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);
+		*HPMforce_return = false;
 		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);
@@ -898,6 +931,7 @@ int64 HP_battle_calc_damage(struct block_list *src, struct block_list *bl, struc
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -924,6 +958,7 @@ int64 HP_battle_calc_gvg_damage(struct block_list *src, struct block_list *bl, i
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -950,6 +985,7 @@ int64 HP_battle_calc_bg_damage(struct block_list *src, struct block_list *bl, in
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -976,6 +1012,7 @@ enum damage_lv HP_battle_weapon_attack(struct block_list *bl, struct block_list
 	enum damage_lv retVal___ = ATK_NONE;
 	if( HPMHooks.count.HP_battle_weapon_attack_pre ) {
 		enum damage_lv (*preHookFunc) (struct block_list *bl, struct block_list *target, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -1003,6 +1040,7 @@ struct Damage HP_battle_calc_weapon_attack(struct block_list *src, struct block_
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1029,6 +1067,7 @@ int HP_battle_delay_damage(int64 tick, int amotion, struct block_list *src, stru
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_delay_damage_pre ) {
 		int (*preHookFunc) (int64 *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);
+		*HPMforce_return = false;
 		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);
@@ -1054,6 +1093,7 @@ void HP_battle_drain(struct map_session_data *sd, struct block_list *tbl, int64
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1079,6 +1119,7 @@ void HP_battle_reflect_damage(struct block_list *target, struct block_list *src,
 	int hIndex = 0;
 	if( HPMHooks.count.HP_battle_reflect_damage_pre ) {
 		void (*preHookFunc) (struct block_list *target, struct block_list *src, struct Damage *wd, uint16 *skill_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_reflect_damage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_battle_reflect_damage_pre[hIndex].func;
 			preHookFunc(target, src, wd, &skill_id);
@@ -1105,6 +1146,7 @@ int HP_battle_attr_ratio(int atk_elem, int def_type, int def_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_attr_ratio_pre ) {
 		int (*preHookFunc) (int *atk_elem, int *def_type, int *def_lv);
+		*HPMforce_return = false;
 		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);
@@ -1131,6 +1173,7 @@ int64 HP_battle_attr_fix(struct block_list *src, struct block_list *target, int6
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1157,6 +1200,7 @@ int64 HP_battle_calc_cardfix(int attack_type, struct block_list *src, struct blo
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1183,6 +1227,7 @@ int64 HP_battle_calc_elefix(struct block_list *src, struct block_list *target, u
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1209,6 +1254,7 @@ int64 HP_battle_calc_masteryfix(struct block_list *src, struct block_list *targe
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1235,6 +1281,7 @@ int HP_battle_calc_chorusbonus(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_calc_chorusbonus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_chorusbonus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_battle_calc_chorusbonus_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -1261,6 +1308,7 @@ int HP_battle_calc_skillratio(int attack_type, struct block_list *src, struct bl
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1287,6 +1335,7 @@ int64 HP_battle_calc_sizefix(struct map_session_data *sd, int64 damage, int type
 	int64 retVal___ = 0;
 	if( HPMHooks.count.HP_battle_calc_sizefix_pre ) {
 		int64 (*preHookFunc) (struct map_session_data *sd, int64 *damage, int *type, int *size, bool *ignore);
+		*HPMforce_return = false;
 		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);
@@ -1313,6 +1362,7 @@ int64 HP_battle_calc_weapon_damage(struct block_list *src, struct block_list *bl
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1339,6 +1389,7 @@ int64 HP_battle_calc_defense(int attack_type, struct block_list *src, struct blo
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1365,6 +1416,7 @@ struct block_list* HP_battle_get_master(struct block_list *src) {
 	struct block_list* retVal___ = NULL;
 	if( HPMHooks.count.HP_battle_get_master_pre ) {
 		struct block_list* (*preHookFunc) (struct block_list *src);
+		*HPMforce_return = false;
 		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);
@@ -1391,6 +1443,7 @@ struct block_list* HP_battle_get_targeted(struct block_list *target) {
 	struct block_list* retVal___ = NULL;
 	if( HPMHooks.count.HP_battle_get_targeted_pre ) {
 		struct block_list* (*preHookFunc) (struct block_list *target);
+		*HPMforce_return = false;
 		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);
@@ -1417,6 +1470,7 @@ struct block_list* HP_battle_get_enemy(struct block_list *target, int type, int
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1443,6 +1497,7 @@ int HP_battle_get_target(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_get_target_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -1469,6 +1524,7 @@ int HP_battle_get_current_skill(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_get_current_skill_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -1495,6 +1551,7 @@ bool HP_battle_check_undead(int race, int element) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_battle_check_undead_pre ) {
 		bool (*preHookFunc) (int *race, int *element);
+		*HPMforce_return = false;
 		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);
@@ -1521,6 +1578,7 @@ int HP_battle_check_target(struct block_list *src, struct block_list *target, in
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_check_target_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *target, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -1547,6 +1605,7 @@ bool HP_battle_check_range(struct block_list *src, struct block_list *bl, int ra
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_battle_check_range_pre ) {
 		bool (*preHookFunc) (struct block_list *src, struct block_list *bl, int *range);
+		*HPMforce_return = false;
 		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);
@@ -1572,6 +1631,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -1598,6 +1658,7 @@ int HP_battle_get_targeted_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_get_targeted_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -1630,6 +1691,7 @@ int HP_battle_get_enemy_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_get_enemy_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -1662,6 +1724,7 @@ int HP_battle_get_enemy_area_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_get_enemy_area_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -1694,6 +1757,7 @@ int HP_battle_delay_damage_sub(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_delay_damage_sub_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -1720,6 +1784,7 @@ int HP_battle_blewcount_bonus(struct map_session_data *sd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_blewcount_bonus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -1746,6 +1811,7 @@ int HP_battle_range_type(struct block_list *src, struct block_list *target, uint
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_range_type_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -1772,6 +1838,7 @@ int64 HP_battle_calc_base_damage(struct block_list *src, struct block_list *bl,
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1798,6 +1865,7 @@ int64 HP_battle_calc_base_damage2(struct status_data *st, struct weapon_atk *wa,
 	int64 retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1825,6 +1893,7 @@ struct Damage HP_battle_calc_misc_attack(struct block_list *src, struct block_li
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1852,6 +1921,7 @@ struct Damage HP_battle_calc_magic_attack(struct block_list *src, struct block_l
 	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);
+		*HPMforce_return = false;
 		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);
@@ -1878,6 +1948,7 @@ int HP_battle_adjust_skill_damage(int m, unsigned short skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_adjust_skill_damage_pre ) {
 		int (*preHookFunc) (int *m, unsigned short *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -1904,6 +1975,7 @@ int64 HP_battle_add_mastery(struct map_session_data *sd, struct block_list *targ
 	int64 retVal___ = 0;
 	if( HPMHooks.count.HP_battle_add_mastery_pre ) {
 		int64 (*preHookFunc) (struct map_session_data *sd, struct block_list *target, int64 *dmg, int *type);
+		*HPMforce_return = false;
 		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);
@@ -1930,6 +2002,7 @@ int HP_battle_calc_drain(int64 damage, int rate, int per) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_calc_drain_pre ) {
 		int (*preHookFunc) (int64 *damage, int *rate, int *per);
+		*HPMforce_return = false;
 		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);
@@ -1956,6 +2029,7 @@ int HP_battle_config_read(const char *cfgName) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_config_read_pre ) {
 		int (*preHookFunc) (const char *cfgName);
+		*HPMforce_return = false;
 		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);
@@ -1981,6 +2055,7 @@ void HP_battle_config_set_defaults(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_battle_config_set_defaults_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -2007,6 +2082,7 @@ int HP_battle_config_set_value(const char *w1, const char *w2) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_config_set_value_pre ) {
 		int (*preHookFunc) (const char *w1, const char *w2);
+		*HPMforce_return = false;
 		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);
@@ -2033,6 +2109,7 @@ int HP_battle_config_get_value(const char *w1) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_config_get_value_pre ) {
 		int (*preHookFunc) (const char *w1);
+		*HPMforce_return = false;
 		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);
@@ -2058,6 +2135,7 @@ void HP_battle_config_adjust(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_battle_config_adjust_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_adjust_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_battle_config_adjust_pre[hIndex].func;
 			preHookFunc();
@@ -2084,6 +2162,7 @@ struct block_list* HP_battle_get_enemy_area(struct block_list *src, int x, int y
 	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);
+		*HPMforce_return = false;
 		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);
@@ -2110,6 +2189,7 @@ int HP_battle_damage_area(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_battle_damage_area_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -2142,6 +2222,7 @@ void HP_bg_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_bg_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -2167,6 +2248,7 @@ void HP_bg_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_bg_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_final_pre[hIndex].func;
 			preHookFunc();
@@ -2193,6 +2275,7 @@ struct bg_arena* HP_bg_name2arena(char *name) {
 	struct bg_arena* retVal___ = NULL;
 	if( HPMHooks.count.HP_bg_name2arena_pre ) {
 		struct bg_arena* (*preHookFunc) (char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_name2arena_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_name2arena_pre[hIndex].func;
 			retVal___ = preHookFunc(name);
@@ -2218,6 +2301,7 @@ void HP_bg_queue_add(struct map_session_data *sd, struct bg_arena *arena, enum b
 	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);
+		*HPMforce_return = false;
 		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);
@@ -2244,6 +2328,7 @@ enum BATTLEGROUNDS_QUEUE_ACK HP_bg_can_queue(struct map_session_data *sd, struct
 	enum BATTLEGROUNDS_QUEUE_ACK retVal___ = BGQA_SUCCESS;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -2270,6 +2355,7 @@ int HP_bg_id2pos(int queue_id, int account_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_id2pos_pre ) {
 		int (*preHookFunc) (int *queue_id, int *account_id);
+		*HPMforce_return = false;
 		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);
@@ -2295,6 +2381,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -2320,6 +2407,7 @@ void HP_bg_begin(struct bg_arena *arena) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_bg_begin_pre ) {
 		void (*preHookFunc) (struct bg_arena *arena);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_begin_pre[hIndex].func;
 			preHookFunc(arena);
@@ -2346,6 +2434,7 @@ int HP_bg_begin_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_begin_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -2371,6 +2460,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pregame_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_queue_pregame_pre[hIndex].func;
 			preHookFunc(arena);
@@ -2397,6 +2487,7 @@ int HP_bg_fillup_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_fillup_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -2422,6 +2513,7 @@ void HP_bg_queue_ready_ack(struct bg_arena *arena, struct map_session_data *sd,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -2447,6 +2539,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -2472,6 +2565,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_check_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_queue_check_pre[hIndex].func;
 			preHookFunc(arena);
@@ -2498,6 +2592,7 @@ struct battleground_data* HP_bg_team_search(int bg_id) {
 	struct battleground_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_bg_team_search_pre ) {
 		struct battleground_data* (*preHookFunc) (int *bg_id);
+		*HPMforce_return = false;
 		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);
@@ -2524,6 +2619,7 @@ struct map_session_data* HP_bg_getavailablesd(struct battleground_data *bgd) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_bg_getavailablesd_pre ) {
 		struct map_session_data* (*preHookFunc) (struct battleground_data *bgd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_getavailablesd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_getavailablesd_pre[hIndex].func;
 			retVal___ = preHookFunc(bgd);
@@ -2550,6 +2646,7 @@ bool HP_bg_team_delete(int bg_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_bg_team_delete_pre ) {
 		bool (*preHookFunc) (int *bg_id);
+		*HPMforce_return = false;
 		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);
@@ -2576,6 +2673,7 @@ bool HP_bg_team_warp(int bg_id, unsigned short map_index, short x, short y) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_bg_team_warp_pre ) {
 		bool (*preHookFunc) (int *bg_id, unsigned short *map_index, short *x, short *y);
+		*HPMforce_return = false;
 		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, &map_index, &x, &y);
@@ -2601,6 +2699,7 @@ void HP_bg_send_dot_remove(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_bg_send_dot_remove_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_dot_remove_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_send_dot_remove_pre[hIndex].func;
 			preHookFunc(sd);
@@ -2627,6 +2726,7 @@ bool HP_bg_team_join(int bg_id, struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_bg_team_join_pre ) {
 		bool (*preHookFunc) (int *bg_id, struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -2653,6 +2753,7 @@ int HP_bg_team_leave(struct map_session_data *sd, enum bg_team_leave_type flag)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_team_leave_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, enum bg_team_leave_type *flag);
+		*HPMforce_return = false;
 		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);
@@ -2679,6 +2780,7 @@ bool HP_bg_member_respawn(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_bg_member_respawn_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -2705,6 +2807,7 @@ int HP_bg_create(unsigned short map_index, short rx, short ry, const char *ev, c
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_create_pre ) {
 		int (*preHookFunc) (unsigned short *map_index, short *rx, short *ry, const char *ev, const char *dev);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_create_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_create_pre[hIndex].func;
 			retVal___ = preHookFunc(&map_index, &rx, &ry, ev, dev);
@@ -2731,6 +2834,7 @@ int HP_bg_team_get_id(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_team_get_id_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -2757,6 +2861,7 @@ bool HP_bg_send_message(struct map_session_data *sd, const char *mes, int len) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_bg_send_message_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len);
+		*HPMforce_return = false;
 		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);
@@ -2783,6 +2888,7 @@ int HP_bg_send_xy_timer_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_send_xy_timer_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -2815,6 +2921,7 @@ int HP_bg_send_xy_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_send_xy_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -2841,6 +2948,7 @@ int HP_bg_afk_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_bg_afk_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_afk_timer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_afk_timer_pre[hIndex].func;
 			retVal___ = preHookFunc(&tid, &tick, &id, &data);
@@ -2867,6 +2975,7 @@ enum bg_queue_types HP_bg_str2teamtype(const char *str) {
 	enum bg_queue_types retVal___ = BGQT_INVALID;
 	if( HPMHooks.count.HP_bg_str2teamtype_pre ) {
 		enum bg_queue_types (*preHookFunc) (const char *str);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_str2teamtype_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_str2teamtype_pre[hIndex].func;
 			retVal___ = preHookFunc(str);
@@ -2892,6 +3001,7 @@ void HP_bg_config_read(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_bg_config_read_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_config_read_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_bg_config_read_pre[hIndex].func;
 			preHookFunc();
@@ -2919,6 +3029,7 @@ bool HP_buyingstore_setup(struct map_session_data *sd, unsigned char slots) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_buyingstore_setup_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, unsigned char *slots);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_setup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_buyingstore_setup_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &slots);
@@ -2944,6 +3055,7 @@ void HP_buyingstore_create(struct map_session_data *sd, int zenylimit, unsigned
 	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);
+		*HPMforce_return = false;
 		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);
@@ -2969,6 +3081,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_close_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_buyingstore_close_pre[hIndex].func;
 			preHookFunc(sd);
@@ -2994,6 +3107,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_open_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_buyingstore_open_pre[hIndex].func;
 			preHookFunc(sd, &account_id);
@@ -3019,6 +3133,7 @@ void HP_buyingstore_trade(struct map_session_data *sd, int account_id, unsigned
 	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);
+		*HPMforce_return = false;
 		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);
@@ -3045,6 +3160,7 @@ bool HP_buyingstore_search(struct map_session_data *sd, unsigned short nameid) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_buyingstore_search_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_search_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_buyingstore_search_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &nameid);
@@ -3071,6 +3187,7 @@ bool HP_buyingstore_searchall(struct map_session_data *sd, const struct s_search
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_buyingstore_searchall_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const struct s_search_store_search *s);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_searchall_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_buyingstore_searchall_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, s);
@@ -3097,6 +3214,7 @@ unsigned int HP_buyingstore_getuid(void) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_buyingstore_getuid_pre ) {
 		unsigned int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_getuid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_buyingstore_getuid_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -3124,6 +3242,7 @@ bool HP_chat_create_pc_chat(struct map_session_data *sd, const char *title, cons
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_create_pc_chat_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub);
+		*HPMforce_return = false;
 		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);
@@ -3150,6 +3269,7 @@ bool HP_chat_join(struct map_session_data *sd, int chatid, const char *pass) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_join_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, int *chatid, const char *pass);
+		*HPMforce_return = false;
 		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);
@@ -3176,6 +3296,7 @@ int HP_chat_leave(struct map_session_data *sd, bool kicked) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chat_leave_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, bool *kicked);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_leave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chat_leave_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &kicked);
@@ -3202,6 +3323,7 @@ bool HP_chat_change_owner(struct map_session_data *sd, const char *nextownername
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_change_owner_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const char *nextownername);
+		*HPMforce_return = false;
 		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);
@@ -3228,6 +3350,7 @@ bool HP_chat_change_status(struct map_session_data *sd, const char *title, const
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_change_status_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const char *title, const char *pass, int *limit, bool *pub);
+		*HPMforce_return = false;
 		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);
@@ -3254,6 +3377,7 @@ bool HP_chat_kick(struct map_session_data *sd, const char *kickusername) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_kick_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const char *kickusername);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_kick_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chat_kick_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, kickusername);
@@ -3280,6 +3404,7 @@ bool HP_chat_create_npc_chat(struct npc_data *nd, const char *title, int limit,
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_create_npc_chat_pre ) {
 		bool (*preHookFunc) (struct npc_data *nd, const char *title, int *limit, bool *pub, int *trigger, const char *ev, int *zeny, int *minLvl, int *maxLvl);
+		*HPMforce_return = false;
 		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);
@@ -3306,6 +3431,7 @@ bool HP_chat_delete_npc_chat(struct npc_data *nd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_delete_npc_chat_pre ) {
 		bool (*preHookFunc) (struct npc_data *nd);
+		*HPMforce_return = false;
 		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);
@@ -3332,6 +3458,7 @@ bool HP_chat_enable_event(struct chat_data *cd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_enable_event_pre ) {
 		bool (*preHookFunc) (struct chat_data *cd);
+		*HPMforce_return = false;
 		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);
@@ -3358,6 +3485,7 @@ bool HP_chat_disable_event(struct chat_data *cd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_disable_event_pre ) {
 		bool (*preHookFunc) (struct chat_data *cd);
+		*HPMforce_return = false;
 		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);
@@ -3384,6 +3512,7 @@ bool HP_chat_npc_kick_all(struct chat_data *cd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_npc_kick_all_pre ) {
 		bool (*preHookFunc) (struct chat_data *cd);
+		*HPMforce_return = false;
 		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);
@@ -3410,6 +3539,7 @@ bool HP_chat_trigger_event(struct chat_data *cd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chat_trigger_event_pre ) {
 		bool (*preHookFunc) (struct chat_data *cd);
+		*HPMforce_return = false;
 		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);
@@ -3436,6 +3566,7 @@ struct chat_data* HP_chat_create(struct block_list *bl, const char *title, const
 	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);
+		*HPMforce_return = false;
 		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);
@@ -3462,6 +3593,7 @@ void HP_chrif_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -3487,6 +3619,7 @@ void HP_chrif_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_final_pre[hIndex].func;
 			preHookFunc();
@@ -3512,6 +3645,7 @@ void HP_chrif_setuserid(char *id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_setuserid_pre ) {
 		void (*preHookFunc) (char *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setuserid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_setuserid_pre[hIndex].func;
 			preHookFunc(id);
@@ -3537,6 +3671,7 @@ void HP_chrif_setpasswd(char *pwd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_setpasswd_pre ) {
 		void (*preHookFunc) (char *pwd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setpasswd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_setpasswd_pre[hIndex].func;
 			preHookFunc(pwd);
@@ -3562,6 +3697,7 @@ void HP_chrif_checkdefaultlogin(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_checkdefaultlogin_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_checkdefaultlogin_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_checkdefaultlogin_pre[hIndex].func;
 			preHookFunc();
@@ -3588,6 +3724,7 @@ bool HP_chrif_setip(const char *ip) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_setip_pre ) {
 		bool (*preHookFunc) (const char *ip);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_setip_pre[hIndex].func;
 			retVal___ = preHookFunc(ip);
@@ -3613,6 +3750,7 @@ void HP_chrif_setport(uint16 port) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_setport_pre ) {
 		void (*preHookFunc) (uint16 *port);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setport_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_setport_pre[hIndex].func;
 			preHookFunc(&port);
@@ -3639,6 +3777,7 @@ int HP_chrif_isconnected(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_isconnected_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_isconnected_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_isconnected_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -3664,6 +3803,7 @@ void HP_chrif_check_shutdown(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_check_shutdown_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_check_shutdown_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_check_shutdown_pre[hIndex].func;
 			preHookFunc();
@@ -3690,6 +3830,7 @@ struct auth_node* HP_chrif_search(int account_id) {
 	struct auth_node* retVal___ = NULL;
 	if( HPMHooks.count.HP_chrif_search_pre ) {
 		struct auth_node* (*preHookFunc) (int *account_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_search_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_search_pre[hIndex].func;
 			retVal___ = preHookFunc(&account_id);
@@ -3716,6 +3857,7 @@ struct auth_node* HP_chrif_auth_check(int account_id, int char_id, enum sd_state
 	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);
+		*HPMforce_return = false;
 		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);
@@ -3742,6 +3884,7 @@ bool HP_chrif_auth_delete(int account_id, int char_id, enum sd_state state) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_auth_delete_pre ) {
 		bool (*preHookFunc) (int *account_id, int *char_id, enum sd_state *state);
+		*HPMforce_return = false;
 		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);
@@ -3768,6 +3911,7 @@ bool HP_chrif_auth_finished(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_auth_finished_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -3793,6 +3937,7 @@ void HP_chrif_authreq(struct map_session_data *sd, bool hstandalone) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_authreq_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, bool *hstandalone);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authreq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_authreq_pre[hIndex].func;
 			preHookFunc(sd, &hstandalone);
@@ -3818,6 +3963,7 @@ void HP_chrif_authok(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_authok_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authok_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_authok_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -3844,6 +3990,7 @@ bool HP_chrif_scdata_request(int account_id, int char_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_scdata_request_pre ) {
 		bool (*preHookFunc) (int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -3870,6 +4017,7 @@ bool HP_chrif_save(struct map_session_data *sd, int flag) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_save_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_save_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &flag);
@@ -3896,6 +4044,7 @@ bool HP_chrif_charselectreq(struct map_session_data *sd, uint32 s_ip) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_charselectreq_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, uint32 *s_ip);
+		*HPMforce_return = false;
 		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);
@@ -3922,6 +4071,7 @@ bool HP_chrif_changemapserver(struct map_session_data *sd, uint32 ip, uint16 por
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_changemapserver_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, uint32 *ip, uint16 *port);
+		*HPMforce_return = false;
 		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);
@@ -3948,6 +4098,7 @@ bool HP_chrif_searchcharid(int char_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_searchcharid_pre ) {
 		bool (*preHookFunc) (int *char_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_searchcharid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_searchcharid_pre[hIndex].func;
 			retVal___ = preHookFunc(&char_id);
@@ -3974,6 +4125,7 @@ bool HP_chrif_changeemail(int id, const char *actual_email, const char *new_emai
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_changeemail_pre ) {
 		bool (*preHookFunc) (int *id, const char *actual_email, const char *new_email);
+		*HPMforce_return = false;
 		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);
@@ -4000,6 +4152,7 @@ bool HP_chrif_char_ask_name(int acc, const char *character_name, unsigned short
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_char_ask_name_pre ) {
 		bool (*preHookFunc) (int *acc, const char *character_name, unsigned short *operation_type, int *year, int *month, int *day, int *hour, int *minute, int *second);
+		*HPMforce_return = false;
 		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);
@@ -4026,6 +4179,7 @@ int HP_chrif_updatefamelist(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_updatefamelist_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_updatefamelist_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -4052,6 +4206,7 @@ bool HP_chrif_buildfamelist(void) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_buildfamelist_pre ) {
 		bool (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_buildfamelist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_buildfamelist_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -4078,6 +4233,7 @@ bool HP_chrif_save_scdata(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_save_scdata_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -4104,6 +4260,7 @@ bool HP_chrif_ragsrvinfo(int base_rate, int job_rate, int drop_rate) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_ragsrvinfo_pre ) {
 		bool (*preHookFunc) (int *base_rate, int *job_rate, int *drop_rate);
+		*HPMforce_return = false;
 		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);
@@ -4130,6 +4287,7 @@ bool HP_chrif_char_offline_nsd(int account_id, int char_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_char_offline_nsd_pre ) {
 		bool (*preHookFunc) (int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -4156,6 +4314,7 @@ bool HP_chrif_char_reset_offline(void) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_char_reset_offline_pre ) {
 		bool (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -4182,6 +4341,7 @@ bool HP_chrif_send_users_tochar(void) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_send_users_tochar_pre ) {
 		bool (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -4208,6 +4368,7 @@ bool HP_chrif_char_online(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_char_online_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -4234,6 +4395,7 @@ bool HP_chrif_changesex(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_changesex_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changesex_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_changesex_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -4260,6 +4422,7 @@ bool HP_chrif_divorce(int partner_id1, int partner_id2) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_divorce_pre ) {
 		bool (*preHookFunc) (int *partner_id1, int *partner_id2);
+		*HPMforce_return = false;
 		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);
@@ -4286,6 +4449,7 @@ bool HP_chrif_removefriend(int char_id, int friend_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_removefriend_pre ) {
 		bool (*preHookFunc) (int *char_id, int *friend_id);
+		*HPMforce_return = false;
 		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);
@@ -4311,6 +4475,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -4337,6 +4502,7 @@ bool HP_chrif_flush(void) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_flush_pre ) {
 		bool (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_flush_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_flush_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -4362,6 +4528,7 @@ void HP_chrif_skillid2idx(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_skillid2idx_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_skillid2idx_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_skillid2idx_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4388,6 +4555,7 @@ bool HP_chrif_sd_to_auth(TBL_PC *sd, enum sd_state state) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_sd_to_auth_pre ) {
 		bool (*preHookFunc) (TBL_PC *sd, enum sd_state *state);
+		*HPMforce_return = false;
 		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);
@@ -4414,6 +4582,7 @@ int HP_chrif_check_connect_char_server(int tid, int64 tick, int id, intptr_t dat
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_check_connect_char_server_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -4440,6 +4609,7 @@ bool HP_chrif_auth_logout(TBL_PC *sd, enum sd_state state) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_auth_logout_pre ) {
 		bool (*preHookFunc) (TBL_PC *sd, enum sd_state *state);
+		*HPMforce_return = false;
 		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);
@@ -4465,6 +4635,7 @@ void HP_chrif_save_ack(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_save_ack_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_ack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_save_ack_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4491,6 +4662,7 @@ int HP_chrif_reconnect(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_reconnect_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -4523,6 +4695,7 @@ int HP_chrif_auth_db_cleanup_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_auth_db_cleanup_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -4555,6 +4728,7 @@ bool HP_chrif_char_ask_name_answer(int acc, const char *player_name, uint16 type
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_char_ask_name_answer_pre ) {
 		bool (*preHookFunc) (int *acc, const char *player_name, uint16 *type, uint16 *answer);
+		*HPMforce_return = false;
 		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;
 			retVal___ = preHookFunc(&acc, player_name, &type, &answer);
@@ -4581,6 +4755,7 @@ int HP_chrif_auth_db_final(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_auth_db_final_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -4613,6 +4788,7 @@ int HP_chrif_send_usercount_tochar(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_send_usercount_tochar_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -4639,6 +4815,7 @@ int HP_chrif_auth_db_cleanup(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_auth_db_cleanup_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -4664,6 +4841,7 @@ void HP_chrif_connect(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_connect_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connect_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_connect_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4689,6 +4867,7 @@ void HP_chrif_connectack(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_connectack_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connectack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_connectack_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4714,6 +4893,7 @@ void HP_chrif_sendmap(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_sendmap_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_sendmap_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4739,6 +4919,7 @@ void HP_chrif_sendmapack(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_sendmapack_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmapack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_sendmapack_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4764,6 +4945,7 @@ void HP_chrif_recvmap(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_recvmap_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvmap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_recvmap_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4790,6 +4972,7 @@ bool HP_chrif_changemapserverack(int account_id, int login_id1, int login_id2, i
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_changemapserverack_pre ) {
 		bool (*preHookFunc) (int *account_id, int *login_id1, int *login_id2, int *char_id, short *map_index, short *x, short *y, uint32 *ip, uint16 *port);
+		*HPMforce_return = false;
 		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);
@@ -4815,6 +4998,7 @@ void HP_chrif_changedsex(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_changedsex_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changedsex_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_changedsex_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4841,6 +5025,7 @@ bool HP_chrif_divorceack(int char_id, int partner_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_divorceack_pre ) {
 		bool (*preHookFunc) (int *char_id, int *partner_id);
+		*HPMforce_return = false;
 		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);
@@ -4866,6 +5051,7 @@ void HP_chrif_idbanned(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_idbanned_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_idbanned_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_idbanned_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4891,6 +5077,7 @@ void HP_chrif_recvfamelist(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_recvfamelist_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvfamelist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_recvfamelist_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4917,6 +5104,7 @@ bool HP_chrif_load_scdata(int fd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_chrif_load_scdata_pre ) {
 		bool (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		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);
@@ -4942,6 +5130,7 @@ void HP_chrif_update_ip(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_update_ip_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_update_ip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_update_ip_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -4968,6 +5157,7 @@ int HP_chrif_disconnectplayer(int fd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_disconnectplayer_pre ) {
 		int (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_disconnectplayer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_disconnectplayer_pre[hIndex].func;
 			retVal___ = preHookFunc(&fd);
@@ -4993,6 +5183,7 @@ void HP_chrif_removemap(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_removemap_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removemap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_removemap_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -5019,6 +5210,7 @@ int HP_chrif_updatefamelist_ack(int fd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_updatefamelist_ack_pre ) {
 		int (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		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);
@@ -5044,6 +5236,7 @@ void HP_chrif_keepalive(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_keepalive_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_keepalive_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -5069,6 +5262,7 @@ void HP_chrif_keepalive_ack(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_keepalive_ack_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_ack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_keepalive_ack_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -5094,6 +5288,7 @@ void HP_chrif_deadopt(int father_id, int mother_id, int child_id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_deadopt_pre ) {
 		void (*preHookFunc) (int *father_id, int *mother_id, int *child_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_deadopt_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_deadopt_pre[hIndex].func;
 			preHookFunc(&father_id, &mother_id, &child_id);
@@ -5119,6 +5314,7 @@ void HP_chrif_authfail(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_authfail_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authfail_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_authfail_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -5144,6 +5340,7 @@ void HP_chrif_on_ready(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_on_ready_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_on_ready_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_on_ready_pre[hIndex].func;
 			preHookFunc();
@@ -5169,6 +5366,7 @@ void HP_chrif_on_disconnect(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_on_disconnect_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_on_disconnect_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_on_disconnect_pre[hIndex].func;
 			preHookFunc();
@@ -5195,6 +5393,7 @@ int HP_chrif_parse(int fd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_chrif_parse_pre ) {
 		int (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_parse_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_parse_pre[hIndex].func;
 			retVal___ = preHookFunc(&fd);
@@ -5220,6 +5419,7 @@ void HP_chrif_save_scdata_single(int account_id, int char_id, short type, struct
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_save_scdata_single_pre ) {
 		void (*preHookFunc) (int *account_id, int *char_id, short *type, struct status_change_entry *sce);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_scdata_single_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_save_scdata_single_pre[hIndex].func;
 			preHookFunc(&account_id, &char_id, &type, sce);
@@ -5245,6 +5445,7 @@ void HP_chrif_del_scdata_single(int account_id, int char_id, short type) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_chrif_del_scdata_single_pre ) {
 		void (*preHookFunc) (int *account_id, int *char_id, short *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_del_scdata_single_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_chrif_del_scdata_single_pre[hIndex].func;
 			preHookFunc(&account_id, &char_id, &type);
@@ -5272,6 +5473,7 @@ int HP_clif_init(bool minimal) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_init_pre ) {
 		int (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_init_pre[hIndex].func;
 			retVal___ = preHookFunc(&minimal);
@@ -5297,6 +5499,7 @@ void HP_clif_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_final_pre[hIndex].func;
 			preHookFunc();
@@ -5323,6 +5526,7 @@ bool HP_clif_setip(const char *ip) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_clif_setip_pre ) {
 		bool (*preHookFunc) (const char *ip);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_setip_pre[hIndex].func;
 			retVal___ = preHookFunc(ip);
@@ -5349,6 +5553,7 @@ bool HP_clif_setbindip(const char *ip) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_clif_setbindip_pre ) {
 		bool (*preHookFunc) (const char *ip);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setbindip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_setbindip_pre[hIndex].func;
 			retVal___ = preHookFunc(ip);
@@ -5374,6 +5579,7 @@ void HP_clif_setport(uint16 port) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_setport_pre ) {
 		void (*preHookFunc) (uint16 *port);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setport_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_setport_pre[hIndex].func;
 			preHookFunc(&port);
@@ -5400,6 +5606,7 @@ uint32 HP_clif_refresh_ip(void) {
 	uint32 retVal___ = 0;
 	if( HPMHooks.count.HP_clif_refresh_ip_pre ) {
 		uint32 (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_ip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_refresh_ip_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -5426,6 +5633,7 @@ bool HP_clif_send(const void *buf, int len, struct block_list *bl, enum send_tar
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_clif_send_pre ) {
 		bool (*preHookFunc) (const void *buf, int *len, struct block_list *bl, enum send_target *type);
+		*HPMforce_return = false;
 		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);
@@ -5452,6 +5660,7 @@ int HP_clif_send_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_send_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -5484,6 +5693,7 @@ int HP_clif_parse(int fd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_parse_pre ) {
 		int (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_parse_pre[hIndex].func;
 			retVal___ = preHookFunc(&fd);
@@ -5510,6 +5720,7 @@ unsigned short HP_clif_parse_cmd(int fd, struct map_session_data *sd) {
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_clif_parse_cmd_pre ) {
 		unsigned short (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -5536,6 +5747,7 @@ unsigned short HP_clif_decrypt_cmd(int cmd, struct map_session_data *sd) {
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_clif_decrypt_cmd_pre ) {
 		unsigned short (*preHookFunc) (int *cmd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -5561,6 +5773,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authok_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_authok_pre[hIndex].func;
 			preHookFunc(sd);
@@ -5586,6 +5799,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authrefuse_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_authrefuse_pre[hIndex].func;
 			preHookFunc(&fd, &error_code);
@@ -5611,6 +5825,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -5636,6 +5851,7 @@ void HP_clif_charselectok(int id, uint8 ok) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_charselectok_pre ) {
 		void (*preHookFunc) (int *id, uint8 *ok);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charselectok_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_charselectok_pre[hIndex].func;
 			preHookFunc(&id, &ok);
@@ -5661,6 +5877,7 @@ void HP_clif_dropflooritem(struct flooritem_data *fitem) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_dropflooritem_pre ) {
 		void (*preHookFunc) (struct flooritem_data *fitem);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropflooritem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_dropflooritem_pre[hIndex].func;
 			preHookFunc(fitem);
@@ -5686,6 +5903,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearflooritem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_clearflooritem_pre[hIndex].func;
 			preHookFunc(fitem, &fd);
@@ -5711,6 +5929,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -5736,6 +5955,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_dropitem_pre[hIndex].func;
 			preHookFunc(sd, &n, &amount);
@@ -5761,6 +5981,7 @@ void HP_clif_delitem(struct map_session_data *sd, int n, int amount, short reaso
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_delitem_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, short *reason);
+		*HPMforce_return = false;
 		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);
@@ -5786,6 +6007,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_takeitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_takeitem_pre[hIndex].func;
 			preHookFunc(src, dst);
@@ -5811,6 +6033,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrowequip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_arrowequip_pre[hIndex].func;
 			preHookFunc(sd, &val);
@@ -5836,6 +6059,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -5861,6 +6085,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -5886,6 +6111,7 @@ void HP_clif_cart_additem(struct map_session_data *sd, int n, int amount, int fa
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_cart_additem_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *n, int *amount, int *fail);
+		*HPMforce_return = false;
 		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);
@@ -5911,6 +6137,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -5936,6 +6163,7 @@ void HP_clif_equipitemack(struct map_session_data *sd, int n, int pos, enum e_EQ
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_equipitemack_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *n, int *pos, enum e_EQUIP_ITEM_ACK *result);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equipitemack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_equipitemack_pre[hIndex].func;
 			preHookFunc(sd, &n, &pos, &result);
@@ -5961,6 +6189,7 @@ void HP_clif_unequipitemack(struct map_session_data *sd, int n, int pos, enum e_
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_unequipitemack_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *n, int *pos, enum e_UNEQUIP_ITEM_ACK *result);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_unequipitemack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_unequipitemack_pre[hIndex].func;
 			preHookFunc(sd, &n, &pos, &result);
@@ -5986,6 +6215,7 @@ void HP_clif_useitemack(struct map_session_data *sd, int index, int amount, bool
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_useitemack_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount, bool *ok);
+		*HPMforce_return = false;
 		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);
@@ -6011,6 +6241,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_addcards_pre[hIndex].func;
 			preHookFunc(buf, item);
@@ -6036,6 +6267,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_addcards2_pre[hIndex].func;
 			preHookFunc(cards, item);
@@ -6061,6 +6293,7 @@ void HP_clif_item_sub(unsigned char *buf, int n, struct item *i, struct item_dat
 	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);
+		*HPMforce_return = false;
 		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);
@@ -6086,6 +6319,7 @@ void HP_clif_getareachar_item(struct map_session_data *sd, struct flooritem_data
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_getareachar_item_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct flooritem_data *fitem);
+		*HPMforce_return = false;
 		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);
@@ -6111,6 +6345,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -6136,6 +6371,7 @@ void HP_clif_cashshop_load(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_cashshop_load_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_load_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_cashshop_load_pre[hIndex].func;
 			preHookFunc();
@@ -6161,6 +6397,7 @@ void HP_clif_package_announce(struct map_session_data *sd, unsigned short nameid
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_package_announce_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid, unsigned short *containerid);
+		*HPMforce_return = false;
 		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);
@@ -6186,6 +6423,7 @@ void HP_clif_item_drop_announce(struct map_session_data *sd, unsigned short name
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_item_drop_announce_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid, char *monsterName);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_drop_announce_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_item_drop_announce_pre[hIndex].func;
 			preHookFunc(sd, &nameid, monsterName);
@@ -6211,6 +6449,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -6236,6 +6475,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -6261,6 +6501,7 @@ void HP_clif_clearunit_delayed(struct block_list *bl, clr_type type, int64 tick)
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_clearunit_delayed_pre ) {
 		void (*preHookFunc) (struct block_list *bl, clr_type *type, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -6286,6 +6527,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_walkok_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_walkok_pre[hIndex].func;
 			preHookFunc(sd);
@@ -6311,6 +6553,7 @@ void HP_clif_move(struct unit_data *ud) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_move_pre ) {
 		void (*preHookFunc) (struct unit_data *ud);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_move_pre[hIndex].func;
 			preHookFunc(ud);
@@ -6336,6 +6579,7 @@ void HP_clif_move2(struct block_list *bl, struct view_data *vd, struct unit_data
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_move2_pre ) {
 		void (*preHookFunc) (struct block_list *bl, struct view_data *vd, struct unit_data *ud);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_move2_pre[hIndex].func;
 			preHookFunc(bl, vd, ud);
@@ -6361,6 +6605,7 @@ void HP_clif_blown(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_blown_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blown_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_blown_pre[hIndex].func;
 			preHookFunc(bl);
@@ -6386,6 +6631,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_slide_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_slide_pre[hIndex].func;
 			preHookFunc(bl, &x, &y);
@@ -6411,6 +6657,7 @@ void HP_clif_fixpos(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_fixpos_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fixpos_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_fixpos_pre[hIndex].func;
 			preHookFunc(bl);
@@ -6436,6 +6683,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changelook_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_changelook_pre[hIndex].func;
 			preHookFunc(bl, &type, &val);
@@ -6461,6 +6709,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changetraplook_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_changetraplook_pre[hIndex].func;
 			preHookFunc(bl, &val);
@@ -6486,6 +6735,7 @@ void HP_clif_refreshlook(struct block_list *bl, int id, int type, int val, enum
 	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);
+		*HPMforce_return = false;
 		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);
@@ -6511,6 +6761,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -6536,6 +6787,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_delunit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_skill_delunit_pre[hIndex].func;
 			preHookFunc(su);
@@ -6561,6 +6813,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillunit_update_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_skillunit_update_pre[hIndex].func;
 			preHookFunc(bl);
@@ -6587,6 +6840,7 @@ int HP_clif_clearunit_delayed_sub(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_clearunit_delayed_sub_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -6612,6 +6866,7 @@ void HP_clif_set_unit_idle(struct block_list *bl, struct map_session_data *tsd,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -6637,6 +6892,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -6662,6 +6918,7 @@ void HP_clif_spawn_unit2(struct block_list *bl, enum send_target target) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_spawn_unit2_pre ) {
 		void (*preHookFunc) (struct block_list *bl, enum send_target *target);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_spawn_unit2_pre[hIndex].func;
 			preHookFunc(bl, &target);
@@ -6687,6 +6944,7 @@ void HP_clif_set_unit_idle2(struct block_list *bl, struct map_session_data *tsd,
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_set_unit_idle2_pre ) {
 		void (*preHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target *target);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_set_unit_idle2_pre[hIndex].func;
 			preHookFunc(bl, tsd, &target);
@@ -6712,6 +6970,7 @@ void HP_clif_set_unit_walking(struct block_list *bl, struct map_session_data *ts
 	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);
+		*HPMforce_return = false;
 		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);
@@ -6738,6 +6997,7 @@ int HP_clif_calc_walkdelay(struct block_list *bl, int delay, int type, int damag
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_calc_walkdelay_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *delay, int *type, int *damage, int *div_);
+		*HPMforce_return = false;
 		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_);
@@ -6763,6 +7023,7 @@ void HP_clif_getareachar_skillunit(struct block_list *bl, struct skill_unit *su,
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_getareachar_skillunit_pre ) {
 		void (*preHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target *target);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_skillunit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_getareachar_skillunit_pre[hIndex].func;
 			preHookFunc(bl, su, &target);
@@ -6788,6 +7049,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -6813,6 +7075,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -6839,6 +7102,7 @@ int HP_clif_getareachar(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_getareachar_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -6870,6 +7134,7 @@ void HP_clif_graffiti_entry(struct block_list *bl, struct skill_unit *su, enum s
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_graffiti_entry_pre ) {
 		void (*preHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target *target);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_graffiti_entry_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_graffiti_entry_pre[hIndex].func;
 			preHookFunc(bl, su, &target);
@@ -6896,6 +7161,7 @@ bool HP_clif_spawn(struct block_list *bl) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_clif_spawn_pre ) {
 		bool (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_spawn_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -6921,6 +7187,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -6946,6 +7213,7 @@ void HP_clif_changemapcell(int fd, int16 m, int x, int y, int type, enum send_ta
 	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);
+		*HPMforce_return = false;
 		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);
@@ -6971,6 +7239,7 @@ void HP_clif_map_property(struct map_session_data *sd, enum map_property propert
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_map_property_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, enum map_property *property);
+		*HPMforce_return = false;
 		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);
@@ -6996,6 +7265,7 @@ void HP_clif_pvpset(struct map_session_data *sd, int pvprank, int pvpnum, int ty
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pvpset_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *pvprank, int *pvpnum, int *type);
+		*HPMforce_return = false;
 		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);
@@ -7021,6 +7291,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7046,6 +7317,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bossmapinfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_bossmapinfo_pre[hIndex].func;
 			preHookFunc(&fd, md, &flag);
@@ -7071,6 +7343,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7096,6 +7369,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_maptypeproperty2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_maptypeproperty2_pre[hIndex].func;
 			preHookFunc(bl, &t);
@@ -7121,6 +7395,7 @@ void HP_clif_changemapserver(struct map_session_data *sd, unsigned short map_ind
 	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);
+		*HPMforce_return = false;
 		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);
@@ -7146,6 +7421,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npcbuysell_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_npcbuysell_pre[hIndex].func;
 			preHookFunc(sd, &id);
@@ -7171,6 +7447,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buylist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_buylist_pre[hIndex].func;
 			preHookFunc(sd, nd);
@@ -7196,6 +7473,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_selllist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_selllist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -7221,6 +7499,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7246,6 +7525,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7271,6 +7551,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7296,6 +7577,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7321,6 +7603,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmes_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_scriptmes_pre[hIndex].func;
 			preHookFunc(sd, &npcid, mes);
@@ -7346,6 +7629,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptnext_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_scriptnext_pre[hIndex].func;
 			preHookFunc(sd, &npcid);
@@ -7371,6 +7655,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclose_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_scriptclose_pre[hIndex].func;
 			preHookFunc(sd, &npcid);
@@ -7396,6 +7681,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmenu_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_scriptmenu_pre[hIndex].func;
 			preHookFunc(sd, &npcid, mes);
@@ -7421,6 +7707,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinput_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_scriptinput_pre[hIndex].func;
 			preHookFunc(sd, &npcid);
@@ -7446,6 +7733,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinputstr_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_scriptinputstr_pre[hIndex].func;
 			preHookFunc(sd, &npcid);
@@ -7471,6 +7759,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cutin_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_cutin_pre[hIndex].func;
 			preHookFunc(sd, image, &type);
@@ -7496,6 +7785,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendfakenpc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_sendfakenpc_pre[hIndex].func;
 			preHookFunc(sd, &npcid);
@@ -7521,6 +7811,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_scriptclear_pre[hIndex].func;
 			preHookFunc(sd, &npcid);
@@ -7546,6 +7837,7 @@ void HP_clif_viewpoint(struct map_session_data *sd, int npc_id, int type, int x,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -7572,6 +7864,7 @@ int HP_clif_damage(struct block_list *src, struct block_list *dst, int sdelay, i
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_damage_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *dst, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_damage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_damage_pre[hIndex].func;
 			retVal___ = preHookFunc(src, dst, &sdelay, &ddelay, &damage, &div, &type, &damage2);
@@ -7597,6 +7890,7 @@ void HP_clif_sitting(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_sitting_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sitting_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_sitting_pre[hIndex].func;
 			preHookFunc(bl);
@@ -7622,6 +7916,7 @@ void HP_clif_standing(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_standing_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_standing_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_standing_pre[hIndex].func;
 			preHookFunc(bl);
@@ -7647,6 +7942,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7672,6 +7968,7 @@ void HP_clif_refresh_storagewindow(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_refresh_storagewindow_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_storagewindow_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_refresh_storagewindow_pre[hIndex].func;
 			preHookFunc(sd);
@@ -7697,6 +7994,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_refresh_pre[hIndex].func;
 			preHookFunc(sd);
@@ -7722,6 +8020,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7747,6 +8046,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7772,6 +8072,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -7797,6 +8098,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranklist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_ranklist_pre[hIndex].func;
 			preHookFunc(sd, &type);
@@ -7822,6 +8124,7 @@ void HP_clif_update_rankingpoint(struct map_session_data *sd, enum fame_list_typ
 	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);
+		*HPMforce_return = false;
 		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);
@@ -7847,6 +8150,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRanklist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pRanklist_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -7872,6 +8176,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hotkeys_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_hotkeys_pre[hIndex].func;
 			preHookFunc(sd);
@@ -7898,6 +8203,7 @@ int HP_clif_insight(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_insight_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -7930,6 +8236,7 @@ int HP_clif_outsight(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_outsight_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -7961,6 +8268,7 @@ void HP_clif_skillcastcancel(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_skillcastcancel_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcastcancel_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_skillcastcancel_pre[hIndex].func;
 			preHookFunc(bl);
@@ -7986,6 +8294,7 @@ void HP_clif_skill_fail(struct map_session_data *sd, uint16 skill_id, enum usesk
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8011,6 +8320,7 @@ void HP_clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsign
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_skill_cooldown_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, unsigned int *duration);
+		*HPMforce_return = false;
 		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, &duration);
@@ -8036,6 +8346,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8061,6 +8372,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8086,6 +8398,7 @@ void HP_clif_skill_produce_mix_list(struct map_session_data *sd, int skill_id, i
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8111,6 +8424,7 @@ void HP_clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8136,6 +8450,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autospell_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_autospell_pre[hIndex].func;
 			preHookFunc(sd, &skill_lv);
@@ -8161,6 +8476,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8186,6 +8502,7 @@ void HP_clif_status_change(struct block_list *bl, int type, int flag, int tick,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8211,6 +8528,7 @@ void HP_clif_insert_card(struct map_session_data *sd, int idx_equip, int idx_car
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8236,6 +8554,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_inventorylist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_inventorylist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -8261,6 +8580,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiplist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_equiplist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -8286,6 +8606,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cartlist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_cartlist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -8311,6 +8632,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8336,6 +8658,7 @@ void HP_clif_clearcart(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_clearcart_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearcart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_clearcart_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -8361,6 +8684,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8386,6 +8710,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8411,6 +8736,7 @@ void HP_clif_item_repair_list(struct map_session_data *sd, struct map_session_da
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8436,6 +8762,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8461,6 +8788,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8486,6 +8814,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8511,6 +8840,7 @@ void HP_clif_item_skill(struct map_session_data *sd, uint16 skill_id, uint16 ski
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_item_skill_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -8536,6 +8866,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8561,6 +8892,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8586,6 +8918,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_noitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_mvp_noitem_pre[hIndex].func;
 			preHookFunc(sd);
@@ -8611,6 +8944,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8636,6 +8970,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_charnameack_pre[hIndex].func;
 			preHookFunc(&fd, bl);
@@ -8661,6 +8996,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8687,6 +9023,7 @@ int HP_clif_hpmeter(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_hpmeter_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_hpmeter_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -8712,6 +9049,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8738,6 +9076,7 @@ int HP_clif_hpmeter_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_hpmeter_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -8769,6 +9108,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8794,6 +9134,7 @@ void HP_clif_get_weapon_view(struct map_session_data *sd, unsigned short *rhand,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8819,6 +9160,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8844,6 +9186,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8869,6 +9212,7 @@ void HP_clif_starskill(struct map_session_data *sd, const char *mapname, int mon
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8894,6 +9238,7 @@ void HP_clif_feel_info(struct map_session_data *sd, unsigned char feel_level, un
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8919,6 +9264,7 @@ void HP_clif_hate_info(struct map_session_data *sd, unsigned char hate_level, in
 	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);
+		*HPMforce_return = false;
 		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);
@@ -8944,6 +9290,7 @@ void HP_clif_mission_info(struct map_session_data *sd, int mob_id, unsigned char
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_mission_info_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *mob_id, unsigned char *progress);
+		*HPMforce_return = false;
 		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);
@@ -8969,6 +9316,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -8994,6 +9342,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partytickack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_partytickack_pre[hIndex].func;
 			preHookFunc(sd, &flag);
@@ -9019,6 +9368,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiptickack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_equiptickack_pre[hIndex].func;
 			preHookFunc(sd, &flag);
@@ -9044,6 +9394,7 @@ void HP_clif_viewequip_ack(struct map_session_data *sd, struct map_session_data
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_viewequip_ack_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		*HPMforce_return = false;
 		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);
@@ -9069,6 +9420,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equpcheckbox_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_equpcheckbox_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9094,6 +9446,7 @@ void HP_clif_displayexp(struct map_session_data *sd, unsigned int exp, char type
 	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);
+		*HPMforce_return = false;
 		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);
@@ -9119,6 +9472,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_font_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_font_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9144,6 +9498,7 @@ void HP_clif_progressbar(struct map_session_data *sd, unsigned int color, unsign
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_progressbar_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, unsigned int *color, unsigned int *second);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_progressbar_pre[hIndex].func;
 			preHookFunc(sd, &color, &second);
@@ -9169,6 +9524,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_abort_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_progressbar_abort_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9194,6 +9550,7 @@ void HP_clif_showdigit(struct map_session_data *sd, unsigned char type, int valu
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_showdigit_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, unsigned char *type, int *value);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showdigit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_showdigit_pre[hIndex].func;
 			preHookFunc(sd, &type, &value);
@@ -9220,6 +9577,7 @@ int HP_clif_elementalconverter_list(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_elementalconverter_list_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -9246,6 +9604,7 @@ int HP_clif_spellbook_list(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_spellbook_list_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -9272,6 +9631,7 @@ int HP_clif_magicdecoy_list(struct map_session_data *sd, uint16 skill_lv, short
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_magicdecoy_list_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv, short *x, short *y);
+		*HPMforce_return = false;
 		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);
@@ -9298,6 +9658,7 @@ int HP_clif_poison_list(struct map_session_data *sd, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_poison_list_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -9324,6 +9685,7 @@ int HP_clif_autoshadowspell_list(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_autoshadowspell_list_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -9350,6 +9712,7 @@ int HP_clif_skill_itemlistwindow(struct map_session_data *sd, uint16 skill_id, u
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_skill_itemlistwindow_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -9375,6 +9738,7 @@ void HP_clif_sc_load(struct block_list *bl, int tid, enum send_target target, in
 	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);
+		*HPMforce_return = false;
 		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);
@@ -9400,6 +9764,7 @@ void HP_clif_sc_end(struct block_list *bl, int tid, enum send_target target, int
 	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);
+		*HPMforce_return = false;
 		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);
@@ -9425,6 +9790,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_initialstatus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_initialstatus_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9450,6 +9816,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -9475,6 +9842,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestatus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_updatestatus_pre[hIndex].func;
 			preHookFunc(sd, &type);
@@ -9500,6 +9868,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changestatus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_changestatus_pre[hIndex].func;
 			preHookFunc(sd, &type, &val);
@@ -9525,6 +9894,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -9550,6 +9920,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_movetoattack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_movetoattack_pre[hIndex].func;
 			preHookFunc(sd, bl);
@@ -9575,6 +9946,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -9600,6 +9972,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameupdate_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_charnameupdate_pre[hIndex].func;
 			preHookFunc(ssd);
@@ -9626,6 +9999,7 @@ int HP_clif_delayquit(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_delayquit_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -9651,6 +10025,7 @@ void HP_clif_getareachar_pc(struct map_session_data *sd, struct map_session_data
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_getareachar_pc_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd);
+		*HPMforce_return = false;
 		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);
@@ -9676,6 +10051,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -9701,6 +10077,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PVPInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PVPInfo_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9726,6 +10103,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blacksmith_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_blacksmith_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9751,6 +10129,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_alchemist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_alchemist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9776,6 +10155,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_taekwon_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_taekwon_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9801,6 +10181,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranking_pk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_ranking_pk_pre[hIndex].func;
 			preHookFunc(sd);
@@ -9826,6 +10207,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quitsave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_quitsave_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -9851,6 +10233,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_misceffect_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_misceffect_pre[hIndex].func;
 			preHookFunc(bl, &type);
@@ -9876,6 +10259,7 @@ void HP_clif_changeoption(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_changeoption_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_changeoption_pre[hIndex].func;
 			preHookFunc(bl);
@@ -9901,6 +10285,7 @@ void HP_clif_changeoption2(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_changeoption2_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_changeoption2_pre[hIndex].func;
 			preHookFunc(bl);
@@ -9926,6 +10311,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_emotion_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_emotion_pre[hIndex].func;
 			preHookFunc(bl, &type);
@@ -9951,6 +10337,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_talkiebox_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_talkiebox_pre[hIndex].func;
 			preHookFunc(bl, talkie);
@@ -9976,6 +10363,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wedding_effect_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_wedding_effect_pre[hIndex].func;
 			preHookFunc(bl);
@@ -10001,6 +10389,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_divorced_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_divorced_pre[hIndex].func;
 			preHookFunc(sd, name);
@@ -10026,6 +10415,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_callpartner_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_callpartner_pre[hIndex].func;
 			preHookFunc(sd);
@@ -10052,6 +10442,7 @@ int HP_clif_skill_damage(struct block_list *src, struct block_list *dst, int64 t
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_skill_damage_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *dst, int64 *tick, int *sdelay, int *ddelay, int64 *damage, int *div, uint16 *skill_id, uint16 *skill_lv, int *type);
+		*HPMforce_return = false;
 		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);
@@ -10078,6 +10469,7 @@ int HP_clif_skill_nodamage(struct block_list *src, struct block_list *dst, uint1
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -10103,6 +10495,7 @@ void HP_clif_skill_poseffect(struct block_list *src, uint16 skill_id, int val, i
 	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, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -10128,6 +10521,7 @@ void HP_clif_skill_estimation(struct map_session_data *sd, struct block_list *ds
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_skill_estimation_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct block_list *dst);
+		*HPMforce_return = false;
 		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);
@@ -10153,6 +10547,7 @@ void HP_clif_skill_warppoint(struct map_session_data *sd, uint16 skill_id, uint1
 	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);
+		*HPMforce_return = false;
 		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);
@@ -10178,6 +10573,7 @@ void HP_clif_skillcasting(struct block_list *bl, int src_id, int dst_id, int dst
 	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);
+		*HPMforce_return = false;
 		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);
@@ -10203,6 +10599,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -10228,6 +10625,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_devotion_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_devotion_pre[hIndex].func;
 			preHookFunc(src, tsd);
@@ -10253,6 +10651,7 @@ void HP_clif_spiritball(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_spiritball_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_spiritball_pre[hIndex].func;
 			preHookFunc(bl);
@@ -10278,6 +10677,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -10303,6 +10703,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -10328,6 +10729,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_effect_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_mvp_effect_pre[hIndex].func;
 			preHookFunc(sd);
@@ -10353,6 +10755,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_heal_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_heal_pre[hIndex].func;
 			preHookFunc(&fd, &type, &val);
@@ -10378,6 +10781,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_resurrection_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_resurrection_pre[hIndex].func;
 			preHookFunc(bl, &type);
@@ -10403,6 +10807,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -10428,6 +10833,7 @@ void HP_clif_weather(int16 m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_weather_pre ) {
 		void (*preHookFunc) (int16 *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_weather_pre[hIndex].func;
 			preHookFunc(&m);
@@ -10453,6 +10859,7 @@ void HP_clif_specialeffect(struct block_list *bl, int type, enum send_target tar
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_specialeffect_pre ) {
 		void (*preHookFunc) (struct block_list *bl, int *type, enum send_target *target);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_specialeffect_pre[hIndex].func;
 			preHookFunc(bl, &type, &target);
@@ -10478,6 +10885,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -10503,6 +10911,7 @@ void HP_clif_specialeffect_value(struct block_list *bl, int effect_id, int num,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -10528,6 +10937,7 @@ void HP_clif_millenniumshield(struct block_list *bl, short shields) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_millenniumshield_pre ) {
 		void (*preHookFunc) (struct block_list *bl, short *shields);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_millenniumshield_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_millenniumshield_pre[hIndex].func;
 			preHookFunc(bl, &shields);
@@ -10553,6 +10963,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charm_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_charm_pre[hIndex].func;
 			preHookFunc(sd, &type);
@@ -10578,6 +10989,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -10603,6 +11015,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_snap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_snap_pre[hIndex].func;
 			preHookFunc(bl, &x, &y);
@@ -10628,6 +11041,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_check_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_weather_check_pre[hIndex].func;
 			preHookFunc(sd);
@@ -10653,6 +11067,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_playBGM_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_playBGM_pre[hIndex].func;
 			preHookFunc(sd, name);
@@ -10678,6 +11093,7 @@ void HP_clif_soundeffect(struct map_session_data *sd, struct block_list *bl, con
 	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);
+		*HPMforce_return = false;
 		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);
@@ -10703,6 +11119,7 @@ void HP_clif_soundeffectall(struct block_list *bl, const char *name, int type, e
 	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);
+		*HPMforce_return = false;
 		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);
@@ -10728,6 +11145,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GlobalMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_GlobalMessage_pre[hIndex].func;
 			preHookFunc(bl, message);
@@ -10753,6 +11171,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_createchat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_createchat_pre[hIndex].func;
 			preHookFunc(sd, &flag);
@@ -10778,6 +11197,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dispchat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_dispchat_pre[hIndex].func;
 			preHookFunc(cd, &fd);
@@ -10803,6 +11223,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatfail_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_joinchatfail_pre[hIndex].func;
 			preHookFunc(sd, &flag);
@@ -10828,6 +11249,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatok_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_joinchatok_pre[hIndex].func;
 			preHookFunc(sd, cd);
@@ -10853,6 +11275,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addchat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_addchat_pre[hIndex].func;
 			preHookFunc(cd, sd);
@@ -10878,6 +11301,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatowner_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_changechatowner_pre[hIndex].func;
 			preHookFunc(cd, sd);
@@ -10903,6 +11327,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_clearchat_pre[hIndex].func;
 			preHookFunc(cd, &fd);
@@ -10928,6 +11353,7 @@ void HP_clif_leavechat(struct chat_data *cd, struct map_session_data *sd, bool f
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_leavechat_pre ) {
 		void (*preHookFunc) (struct chat_data *cd, struct map_session_data *sd, bool *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_leavechat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_leavechat_pre[hIndex].func;
 			preHookFunc(cd, sd, &flag);
@@ -10953,6 +11379,7 @@ void HP_clif_changechatstatus(struct chat_data *cd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_changechatstatus_pre ) {
 		void (*preHookFunc) (struct chat_data *cd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatstatus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_changechatstatus_pre[hIndex].func;
 			preHookFunc(cd);
@@ -10978,6 +11405,7 @@ void HP_clif_wis_message(int fd, const char *nick, const char *mes, size_t mes_l
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_wis_message_pre ) {
 		void (*preHookFunc) (int *fd, const char *nick, const char *mes, size_t *mes_len);
+		*HPMforce_return = false;
 		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);
@@ -11003,6 +11431,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -11028,6 +11457,7 @@ void HP_clif_disp_message(struct block_list *src, const char *mes, size_t len, e
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_disp_message_pre ) {
 		void (*preHookFunc) (struct block_list *src, const char *mes, size_t *len, enum send_target *target);
+		*HPMforce_return = false;
 		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);
@@ -11053,6 +11483,7 @@ void HP_clif_broadcast(struct block_list *bl, const char *mes, size_t len, int t
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_broadcast_pre ) {
 		void (*preHookFunc) (struct block_list *bl, const char *mes, size_t *len, int *type, enum send_target *target);
+		*HPMforce_return = false;
 		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);
@@ -11078,6 +11509,7 @@ void HP_clif_broadcast2(struct block_list *bl, const char *mes, size_t len, unsi
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_broadcast2_pre ) {
 		void (*preHookFunc) (struct block_list *bl, const char *mes, size_t *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY, enum send_target *target);
+		*HPMforce_return = false;
 		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);
@@ -11103,6 +11535,7 @@ void HP_clif_messagecolor(struct block_list *bl, unsigned int color, const char
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_messagecolor_pre ) {
 		void (*preHookFunc) (struct block_list *bl, unsigned int *color, const char *msg);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_messagecolor_pre[hIndex].func;
 			preHookFunc(bl, &color, msg);
@@ -11128,6 +11561,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -11153,6 +11587,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_msg_pre[hIndex].func;
 			preHookFunc(sd, &id);
@@ -11178,6 +11613,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -11203,6 +11639,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -11228,6 +11665,7 @@ void HP_clif_msgtable(int fd, int line) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_msgtable_pre ) {
 		void (*preHookFunc) (int *fd, int *line);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_msgtable_pre[hIndex].func;
 			preHookFunc(&fd, &line);
@@ -11253,6 +11691,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -11278,6 +11717,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_message_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_message_pre[hIndex].func;
 			preHookFunc(&fd, mes);
@@ -11303,6 +11743,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messageln_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_messageln_pre[hIndex].func;
 			preHookFunc(&fd, mes);
@@ -11329,6 +11770,7 @@ int HP_clif_colormes(int fd, enum clif_colors color, const char *msg) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_colormes_pre ) {
 		int (*preHookFunc) (int *fd, enum clif_colors *color, const char *msg);
+		*HPMforce_return = false;
 		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);
@@ -11355,6 +11797,7 @@ bool HP_clif_process_message(struct map_session_data *sd, int format, char **nam
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_clif_process_message_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, int *format, char **name_, size_t *namelen_, char **message_, size_t *messagelen_);
+		*HPMforce_return = false;
 		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_);
@@ -11380,6 +11823,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisexin_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_wisexin_pre[hIndex].func;
 			preHookFunc(sd, &type, &flag);
@@ -11405,6 +11849,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisall_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_wisall_pre[hIndex].func;
 			preHookFunc(sd, &type, &flag);
@@ -11430,6 +11875,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PMIgnoreList_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PMIgnoreList_pre[hIndex].func;
 			preHookFunc(sd);
@@ -11455,6 +11901,7 @@ void HP_clif_ShowScript(struct block_list *bl, const char *message) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_ShowScript_pre ) {
 		void (*preHookFunc) (struct block_list *bl, const char *message);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ShowScript_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_ShowScript_pre[hIndex].func;
 			preHookFunc(bl, message);
@@ -11480,6 +11927,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_traderequest_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_traderequest_pre[hIndex].func;
 			preHookFunc(sd, name);
@@ -11505,6 +11953,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradestart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_tradestart_pre[hIndex].func;
 			preHookFunc(sd, &type);
@@ -11530,6 +11979,7 @@ void HP_clif_tradeadditem(struct map_session_data *sd, struct map_session_data *
 	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);
+		*HPMforce_return = false;
 		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);
@@ -11555,6 +12005,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeitemok_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_tradeitemok_pre[hIndex].func;
 			preHookFunc(sd, &index, &fail);
@@ -11580,6 +12031,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -11605,6 +12057,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecancelled_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_tradecancelled_pre[hIndex].func;
 			preHookFunc(sd);
@@ -11630,6 +12083,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecompleted_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_tradecompleted_pre[hIndex].func;
 			preHookFunc(sd, &fail);
@@ -11655,6 +12109,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeundo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_tradeundo_pre[hIndex].func;
 			preHookFunc(sd);
@@ -11680,6 +12135,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvendingreq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_openvendingreq_pre[hIndex].func;
 			preHookFunc(sd, &num);
@@ -11705,6 +12161,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showvendingboard_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_showvendingboard_pre[hIndex].func;
 			preHookFunc(bl, message, &fd);
@@ -11730,6 +12187,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_closevendingboard_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_closevendingboard_pre[hIndex].func;
 			preHookFunc(bl, &fd);
@@ -11755,6 +12213,7 @@ void HP_clif_vendinglist(struct map_session_data *sd, unsigned int id, struct s_
 	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);
+		*HPMforce_return = false;
 		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);
@@ -11780,6 +12239,7 @@ void HP_clif_buyvending(struct map_session_data *sd, int index, int amount, int
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_buyvending_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount, int *fail);
+		*HPMforce_return = false;
 		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);
@@ -11805,6 +12265,7 @@ void HP_clif_openvending(struct map_session_data *sd, int id, struct s_vending *
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_openvending_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *id, struct s_vending *vending_list);
+		*HPMforce_return = false;
 		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);
@@ -11830,6 +12291,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendingreport_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_vendingreport_pre[hIndex].func;
 			preHookFunc(sd, &index, &amount);
@@ -11855,6 +12317,7 @@ void HP_clif_storagelist(struct map_session_data *sd, struct item *items, int it
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_storagelist_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct item *items, int *items_length);
+		*HPMforce_return = false;
 		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);
@@ -11880,6 +12343,7 @@ void HP_clif_updatestorageamount(struct map_session_data *sd, int amount, int ma
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_updatestorageamount_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *amount, int *max_amount);
+		*HPMforce_return = false;
 		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);
@@ -11905,6 +12369,7 @@ void HP_clif_storageitemadded(struct map_session_data *sd, struct item *i, int i
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_storageitemadded_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct item *i, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -11930,6 +12395,7 @@ void HP_clif_storageitemremoved(struct map_session_data *sd, int index, int amou
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_storageitemremoved_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemremoved_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_storageitemremoved_pre[hIndex].func;
 			preHookFunc(sd, &index, &amount);
@@ -11955,6 +12421,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageclose_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_storageclose_pre[hIndex].func;
 			preHookFunc(sd);
@@ -11980,6 +12447,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfoblock_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_skillinfoblock_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12005,6 +12473,7 @@ void HP_clif_skillup(struct map_session_data *sd, uint16 skill_id, int skill_lv,
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_skillup_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *skill_lv, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_skillup_pre[hIndex].func;
 			preHookFunc(sd, &skill_id, &skill_lv, &flag);
@@ -12030,6 +12499,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12055,6 +12525,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addskill_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_addskill_pre[hIndex].func;
 			preHookFunc(sd, &id);
@@ -12080,6 +12551,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_deleteskill_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_deleteskill_pre[hIndex].func;
 			preHookFunc(sd, &id);
@@ -12105,6 +12577,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12130,6 +12603,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12155,6 +12629,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12180,6 +12655,7 @@ void HP_clif_party_invite(struct map_session_data *sd, struct map_session_data *
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_party_invite_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		*HPMforce_return = false;
 		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);
@@ -12205,6 +12681,7 @@ void HP_clif_party_inviteack(struct map_session_data *sd, const char *nick, int
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_party_inviteack_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, const char *nick, int *result);
+		*HPMforce_return = false;
 		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);
@@ -12230,6 +12707,7 @@ void HP_clif_party_option(struct party_data *p, struct map_session_data *sd, int
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_party_option_pre ) {
 		void (*preHookFunc) (struct party_data *p, struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -12255,6 +12733,7 @@ void HP_clif_party_withdraw(struct party_data *p, struct map_session_data *sd, i
 	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);
+		*HPMforce_return = false;
 		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);
@@ -12280,6 +12759,7 @@ void HP_clif_party_message(struct party_data *p, int account_id, const char *mes
 	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);
+		*HPMforce_return = false;
 		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);
@@ -12305,6 +12785,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_party_xy_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12330,6 +12811,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12355,6 +12837,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_hp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_party_hp_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12380,6 +12863,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12405,6 +12889,7 @@ void HP_clif_party_show_picker(struct map_session_data *sd, struct item *item_da
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_party_show_picker_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct item *item_data);
+		*HPMforce_return = false;
 		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);
@@ -12430,6 +12915,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partyinvitationstate_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_partyinvitationstate_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12455,6 +12941,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12480,6 +12967,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12505,6 +12993,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_masterormember_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_masterormember_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12530,6 +13019,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_basicinfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_basicinfo_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12555,6 +13045,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceinfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_allianceinfo_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12580,6 +13071,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_memberlist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12605,6 +13097,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_skillinfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_skillinfo_pre[hIndex].func;
 			preHookFunc(sd);
@@ -12630,6 +13123,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12655,6 +13149,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12680,6 +13175,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12705,6 +13201,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12730,6 +13227,7 @@ void HP_clif_guild_leave(struct map_session_data *sd, const char *name, const ch
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_guild_leave_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, const char *name, const char *mes);
+		*HPMforce_return = false;
 		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);
@@ -12755,6 +13253,7 @@ void HP_clif_guild_expulsion(struct map_session_data *sd, const char *name, cons
 	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);
+		*HPMforce_return = false;
 		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);
@@ -12780,6 +13279,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12805,6 +13305,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12830,6 +13331,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12855,6 +13357,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12880,6 +13383,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12905,6 +13409,7 @@ void HP_clif_guild_message(struct guild *g, int account_id, const char *mes, int
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_guild_message_pre ) {
 		void (*preHookFunc) (struct guild *g, int *account_id, const char *mes, int *len);
+		*HPMforce_return = false;
 		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);
@@ -12930,6 +13435,7 @@ void HP_clif_guild_reqalliance(struct map_session_data *sd, int account_id, cons
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_guild_reqalliance_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *account_id, const char *name);
+		*HPMforce_return = false;
 		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);
@@ -12955,6 +13461,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -12980,6 +13487,7 @@ void HP_clif_guild_delalliance(struct map_session_data *sd, int guild_id, int fl
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_guild_delalliance_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -13005,6 +13513,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13030,6 +13539,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13055,6 +13565,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_xy_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13080,6 +13591,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13105,6 +13617,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13130,6 +13643,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionnamelist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_positionnamelist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13155,6 +13669,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positioninfolist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_positioninfolist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13180,6 +13695,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsionlist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_guild_expulsionlist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13206,6 +13722,7 @@ bool HP_clif_validate_emblem(const uint8 *emblem, unsigned long emblem_len) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_clif_validate_emblem_pre ) {
 		bool (*preHookFunc) (const uint8 *emblem, unsigned long *emblem_len);
+		*HPMforce_return = false;
 		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);
@@ -13231,6 +13748,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_hp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_bg_hp_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13256,6 +13774,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_bg_xy_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13281,6 +13800,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13306,6 +13826,7 @@ void HP_clif_bg_message(struct battleground_data *bgd, int src_id, const char *n
 	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, size_t *len);
+		*HPMforce_return = false;
 		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);
@@ -13331,6 +13852,7 @@ void HP_clif_bg_updatescore(int16 m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_bg_updatescore_pre ) {
 		void (*preHookFunc) (int16 *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_bg_updatescore_pre[hIndex].func;
 			preHookFunc(&m);
@@ -13356,6 +13878,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13381,6 +13904,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_area_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_sendbgemblem_area_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13406,6 +13930,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13432,6 +13957,7 @@ int HP_clif_instance(int instance_id, int type, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_instance_pre ) {
 		int (*preHookFunc) (int *instance_id, int *type, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -13457,6 +13983,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13482,6 +14009,7 @@ void HP_clif_instance_leave(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_instance_leave_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_leave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_instance_leave_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -13507,6 +14035,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_catch_process_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_catch_process_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13532,6 +14061,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13557,6 +14087,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendegg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_sendegg_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13582,6 +14113,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petstatus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_send_petstatus_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13607,6 +14139,7 @@ void HP_clif_send_petdata(struct map_session_data *sd, struct pet_data *pd, int
 	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);
+		*HPMforce_return = false;
 		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);
@@ -13632,6 +14165,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13657,6 +14191,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13683,6 +14218,7 @@ int HP_clif_friendslist_toggle_sub(struct map_session_data *sd, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_friendslist_toggle_sub_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -13714,6 +14250,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_send_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_friendslist_send_pre[hIndex].func;
 			preHookFunc(sd);
@@ -13739,6 +14276,7 @@ void HP_clif_friendslist_reqack(struct map_session_data *sd, struct map_session_
 	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);
+		*HPMforce_return = false;
 		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);
@@ -13764,6 +14302,7 @@ void HP_clif_friendslist_toggle(struct map_session_data *sd, int account_id, int
 	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);
+		*HPMforce_return = false;
 		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);
@@ -13789,6 +14328,7 @@ void HP_clif_friendlist_req(struct map_session_data *sd, int account_id, int cha
 	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);
+		*HPMforce_return = false;
 		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);
@@ -13814,6 +14354,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13839,6 +14380,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13864,6 +14406,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -13889,6 +14432,7 @@ void HP_clif_GM_silence(struct map_session_data *sd, struct map_session_data *ts
 	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);
+		*HPMforce_return = false;
 		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);
@@ -13914,6 +14458,7 @@ void HP_clif_account_name(struct map_session_data *sd, int account_id, const cha
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_account_name_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *account_id, const char *accname);
+		*HPMforce_return = false;
 		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);
@@ -13939,6 +14484,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_check_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_check_pre[hIndex].func;
 			preHookFunc(&fd, pl_sd);
@@ -13964,6 +14510,7 @@ void HP_clif_hominfo(struct map_session_data *sd, struct homun_data *hd, int fla
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_hominfo_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct homun_data *hd, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hominfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_hominfo_pre[hIndex].func;
 			preHookFunc(sd, hd, &flag);
@@ -13989,6 +14536,7 @@ void HP_clif_homskillinfoblock(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_homskillinfoblock_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillinfoblock_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_homskillinfoblock_pre[hIndex].func;
 			preHookFunc(sd);
@@ -14014,6 +14562,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_homskillup_pre[hIndex].func;
 			preHookFunc(sd, &skill_id);
@@ -14039,6 +14588,7 @@ void HP_clif_hom_food(struct map_session_data *sd, int foodid, int fail) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_hom_food_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *foodid, int *fail);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hom_food_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_hom_food_pre[hIndex].func;
 			preHookFunc(sd, &foodid, &fail);
@@ -14064,6 +14614,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14089,6 +14640,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14114,6 +14666,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14139,6 +14692,7 @@ void HP_clif_quest_add(struct map_session_data *sd, struct quest *qd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_quest_add_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct quest *qd);
+		*HPMforce_return = false;
 		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);
@@ -14164,6 +14718,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14189,6 +14744,7 @@ void HP_clif_quest_update_status(struct map_session_data *sd, int quest_id, bool
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_quest_update_status_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *quest_id, bool *active);
+		*HPMforce_return = false;
 		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);
@@ -14214,6 +14770,7 @@ void HP_clif_quest_update_objective(struct map_session_data *sd, struct quest *q
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_quest_update_objective_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct quest *qd);
+		*HPMforce_return = false;
 		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);
@@ -14239,6 +14796,7 @@ void HP_clif_quest_show_event(struct map_session_data *sd, struct block_list *bl
 	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);
+		*HPMforce_return = false;
 		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);
@@ -14264,6 +14822,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14289,6 +14848,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14314,6 +14874,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14339,6 +14900,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14364,6 +14926,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14389,6 +14952,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14414,6 +14978,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_refreshinbox_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_mail_refreshinbox_pre[hIndex].func;
 			preHookFunc(sd);
@@ -14439,6 +15004,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14464,6 +15030,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14489,6 +15056,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_openwindow_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_auction_openwindow_pre[hIndex].func;
 			preHookFunc(sd);
@@ -14514,6 +15082,7 @@ void HP_clif_auction_results(struct map_session_data *sd, short count, short pag
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_auction_results_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, short *count, short *pages, uint8 *buf);
+		*HPMforce_return = false;
 		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);
@@ -14539,6 +15108,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14564,6 +15134,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14589,6 +15160,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14614,6 +15186,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_info_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_mercenary_info_pre[hIndex].func;
 			preHookFunc(sd);
@@ -14639,6 +15212,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_skillblock_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_mercenary_skillblock_pre[hIndex].func;
 			preHookFunc(sd);
@@ -14664,6 +15238,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14689,6 +15264,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14714,6 +15290,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14739,6 +15316,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -14764,6 +15342,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRegisterAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingRegisterAck_pre[hIndex].func;
 			preHookFunc(sd, &flag);
@@ -14789,6 +15368,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteAck_pre[hIndex].func;
 			preHookFunc(sd, &flag);
@@ -14814,6 +15394,7 @@ void HP_clif_PartyBookingSearchAck(int fd, struct party_booking_ad_info **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);
+		*HPMforce_return = false;
 		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);
@@ -14839,6 +15420,7 @@ void HP_clif_PartyBookingUpdateNotify(struct map_session_data *sd, struct party_
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyBookingUpdateNotify_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingUpdateNotify_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingUpdateNotify_pre[hIndex].func;
 			preHookFunc(sd, pb_ad);
@@ -14864,6 +15446,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteNotify_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteNotify_pre[hIndex].func;
 			preHookFunc(sd, &index);
@@ -14889,6 +15472,7 @@ void HP_clif_PartyBookingInsertNotify(struct map_session_data *sd, struct party_
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyBookingInsertNotify_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingInsertNotify_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingInsertNotify_pre[hIndex].func;
 			preHookFunc(sd, pb_ad);
@@ -14914,6 +15498,7 @@ void HP_clif_PartyRecruitRegisterAck(struct map_session_data *sd, int flag) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyRecruitRegisterAck_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitRegisterAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyRecruitRegisterAck_pre[hIndex].func;
 			preHookFunc(sd, &flag);
@@ -14939,6 +15524,7 @@ void HP_clif_PartyRecruitDeleteAck(struct map_session_data *sd, int flag) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyRecruitDeleteAck_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitDeleteAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyRecruitDeleteAck_pre[hIndex].func;
 			preHookFunc(sd, &flag);
@@ -14964,6 +15550,7 @@ void HP_clif_PartyRecruitSearchAck(int fd, struct party_booking_ad_info **result
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyRecruitSearchAck_pre ) {
 		void (*preHookFunc) (int *fd, struct party_booking_ad_info **results, int *count, bool *more_result);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitSearchAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyRecruitSearchAck_pre[hIndex].func;
 			preHookFunc(&fd, results, &count, &more_result);
@@ -14989,6 +15576,7 @@ void HP_clif_PartyRecruitUpdateNotify(struct map_session_data *sd, struct party_
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyRecruitUpdateNotify_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitUpdateNotify_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyRecruitUpdateNotify_pre[hIndex].func;
 			preHookFunc(sd, pb_ad);
@@ -15014,6 +15602,7 @@ void HP_clif_PartyRecruitDeleteNotify(struct map_session_data *sd, int index) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyRecruitDeleteNotify_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitDeleteNotify_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyRecruitDeleteNotify_pre[hIndex].func;
 			preHookFunc(sd, &index);
@@ -15039,6 +15628,7 @@ void HP_clif_PartyRecruitInsertNotify(struct map_session_data *sd, struct party_
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyRecruitInsertNotify_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitInsertNotify_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyRecruitInsertNotify_pre[hIndex].func;
 			preHookFunc(sd, pb_ad);
@@ -15064,6 +15654,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingVolunteerInfo_pre[hIndex].func;
 			preHookFunc(&index, sd);
@@ -15089,6 +15680,7 @@ void HP_clif_PartyBookingRefuseVolunteer(unsigned int aid, struct map_session_da
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_pre ) {
 		void (*preHookFunc) (unsigned int *aid, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingRefuseVolunteer_pre[hIndex].func;
 			preHookFunc(&aid, sd);
@@ -15114,6 +15706,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingCancelVolunteer_pre[hIndex].func;
 			preHookFunc(&index, sd);
@@ -15139,6 +15732,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingAddFilteringList_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingAddFilteringList_pre[hIndex].func;
 			preHookFunc(&index, sd);
@@ -15164,6 +15758,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSubFilteringList_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_PartyBookingSubFilteringList_pre[hIndex].func;
 			preHookFunc(&gid, sd);
@@ -15189,6 +15784,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_buyingstore_open_pre[hIndex].func;
 			preHookFunc(sd);
@@ -15214,6 +15810,7 @@ void HP_clif_buyingstore_open_failed(struct map_session_data *sd, unsigned short
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15239,6 +15836,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_myitemlist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_buyingstore_myitemlist_pre[hIndex].func;
 			preHookFunc(sd);
@@ -15264,6 +15862,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_pre[hIndex].func;
 			preHookFunc(sd);
@@ -15289,6 +15888,7 @@ void HP_clif_buyingstore_entry_single(struct map_session_data *sd, struct map_se
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15314,6 +15914,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -15339,6 +15940,7 @@ void HP_clif_buyingstore_disappear_entry_single(struct map_session_data *sd, str
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15364,6 +15966,7 @@ void HP_clif_buyingstore_itemlist(struct map_session_data *sd, struct map_sessio
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_buyingstore_itemlist_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
+		*HPMforce_return = false;
 		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);
@@ -15389,6 +15992,7 @@ void HP_clif_buyingstore_trade_failed_buyer(struct map_session_data *sd, short r
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, short *result);
+		*HPMforce_return = false;
 		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);
@@ -15414,6 +16018,7 @@ void HP_clif_buyingstore_update_item(struct map_session_data *sd, unsigned short
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15439,6 +16044,7 @@ void HP_clif_buyingstore_delete_item(struct map_session_data *sd, short index, u
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15464,6 +16070,7 @@ void HP_clif_buyingstore_trade_failed_seller(struct map_session_data *sd, short
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15489,6 +16096,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -15514,6 +16122,7 @@ void HP_clif_search_store_info_failed(struct map_session_data *sd, unsigned char
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_search_store_info_failed_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, unsigned char *reason);
+		*HPMforce_return = false;
 		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);
@@ -15539,6 +16148,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -15564,6 +16174,7 @@ void HP_clif_search_store_info_click_ack(struct map_session_data *sd, short x, s
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15589,6 +16200,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_info_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_elemental_info_pre[hIndex].func;
 			preHookFunc(sd);
@@ -15614,6 +16226,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -15639,6 +16252,7 @@ void HP_clif_bgqueue_ack(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_A
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15664,6 +16278,7 @@ void HP_clif_bgqueue_notice_delete(struct map_session_data *sd, enum BATTLEGROUN
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15689,6 +16304,7 @@ void HP_clif_bgqueue_update_info(struct map_session_data *sd, unsigned char aren
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15714,6 +16330,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -15739,6 +16356,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_pcleft_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_bgqueue_pcleft_pre[hIndex].func;
 			preHookFunc(sd);
@@ -15764,6 +16382,7 @@ void HP_clif_bgqueue_battlebegins(struct map_session_data *sd, unsigned char are
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15789,6 +16408,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -15814,6 +16434,7 @@ void HP_clif_adopt_request(struct map_session_data *sd, struct map_session_data
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15839,6 +16460,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -15864,6 +16486,7 @@ void HP_clif_notify_time(struct map_session_data *sd, int64 time) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_notify_time_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int64 *time);
+		*HPMforce_return = false;
 		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);
@@ -15889,6 +16512,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -15914,6 +16538,7 @@ void HP_clif_noask_sub(struct map_session_data *src, struct map_session_data *ta
 	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);
+		*HPMforce_return = false;
 		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);
@@ -15939,6 +16564,7 @@ void HP_clif_bc_ready(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_bc_ready_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bc_ready_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_bc_ready_pre[hIndex].func;
 			preHookFunc();
@@ -15965,6 +16591,7 @@ int HP_clif_undisguise_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_undisguise_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -15990,6 +16617,7 @@ void HP_clif_chsys_create(struct hChSysCh *channel, char *name, char *pass, unsi
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_chsys_create_pre ) {
 		void (*preHookFunc) (struct hChSysCh *channel, char *name, char *pass, unsigned char *color);
+		*HPMforce_return = false;
 		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);
@@ -16015,6 +16643,7 @@ void HP_clif_chsys_msg(struct hChSysCh *channel, struct map_session_data *sd, ch
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_chsys_msg_pre ) {
 		void (*preHookFunc) (struct hChSysCh *channel, struct map_session_data *sd, char *msg);
+		*HPMforce_return = false;
 		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);
@@ -16040,6 +16669,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -16065,6 +16695,7 @@ void HP_clif_chsys_send(struct hChSysCh *channel, struct map_session_data *sd, c
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_chsys_send_pre ) {
 		void (*preHookFunc) (struct hChSysCh *channel, struct map_session_data *sd, const char *msg);
+		*HPMforce_return = false;
 		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);
@@ -16090,6 +16721,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -16115,6 +16747,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -16140,6 +16773,7 @@ void HP_clif_chsys_delete(struct hChSysCh *channel) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_chsys_delete_pre ) {
 		void (*preHookFunc) (struct hChSysCh *channel);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_delete_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_chsys_delete_pre[hIndex].func;
 			preHookFunc(channel);
@@ -16165,6 +16799,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_mjoin_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_chsys_mjoin_pre[hIndex].func;
 			preHookFunc(sd);
@@ -16190,6 +16825,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_quit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_chsys_quit_pre[hIndex].func;
 			preHookFunc(sd);
@@ -16215,6 +16851,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_chsys_quitg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_chsys_quitg_pre[hIndex].func;
 			preHookFunc(sd);
@@ -16240,6 +16877,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -16265,6 +16903,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -16290,6 +16929,7 @@ void HP_clif_bank_deposit(struct map_session_data *sd, enum e_BANKING_DEPOSIT_AC
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_bank_deposit_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, enum e_BANKING_DEPOSIT_ACK *reason);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bank_deposit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_bank_deposit_pre[hIndex].func;
 			preHookFunc(sd, &reason);
@@ -16315,6 +16955,7 @@ void HP_clif_bank_withdraw(struct map_session_data *sd, enum e_BANKING_WITHDRAW_
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_bank_withdraw_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, enum e_BANKING_WITHDRAW_ACK *reason);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bank_withdraw_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_bank_withdraw_pre[hIndex].func;
 			preHookFunc(sd, &reason);
@@ -16340,6 +16981,7 @@ void HP_clif_show_modifiers(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_show_modifiers_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_show_modifiers_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_show_modifiers_pre[hIndex].func;
 			preHookFunc(sd);
@@ -16365,6 +17007,7 @@ void HP_clif_notify_bounditem(struct map_session_data *sd, unsigned short index)
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_notify_bounditem_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, unsigned short *index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_bounditem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_notify_bounditem_pre[hIndex].func;
 			preHookFunc(sd, &index);
@@ -16391,6 +17034,7 @@ int HP_clif_delay_damage(int64 tick, struct block_list *src, struct block_list *
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_delay_damage_pre ) {
 		int (*preHookFunc) (int64 *tick, struct block_list *src, struct block_list *dst, int *sdelay, int *ddelay, int64 *in_damage, short *div, unsigned char *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delay_damage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_delay_damage_pre[hIndex].func;
 			retVal___ = preHookFunc(&tick, src, dst, &sdelay, &ddelay, &in_damage, &div, &type);
@@ -16417,6 +17061,7 @@ int HP_clif_delay_damage_sub(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_clif_delay_damage_sub_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delay_damage_sub_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_delay_damage_sub_pre[hIndex].func;
 			retVal___ = preHookFunc(&tid, &tick, &id, &data);
@@ -16442,6 +17087,7 @@ void HP_clif_npc_market_open(struct map_session_data *sd, struct npc_data *nd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_npc_market_open_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_market_open_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_npc_market_open_pre[hIndex].func;
 			preHookFunc(sd, nd);
@@ -16467,6 +17113,7 @@ void HP_clif_npc_market_purchase_ack(struct map_session_data *sd, struct packet_
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_npc_market_purchase_ack_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct packet_npc_market_purchase *req, unsigned char *response);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_market_purchase_ack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_npc_market_purchase_ack_pre[hIndex].func;
 			preHookFunc(sd, req, &response);
@@ -16492,6 +17139,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWantToConnection_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pWantToConnection_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16517,6 +17165,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLoadEndAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pLoadEndAck_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16542,6 +17191,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTickSend_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTickSend_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16567,6 +17217,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkey_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pHotkey_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16592,6 +17243,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProgressbar_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pProgressbar_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16617,6 +17269,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWalkToXY_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pWalkToXY_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16642,6 +17295,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pQuitGame_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pQuitGame_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16667,6 +17321,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetCharNameRequest_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGetCharNameRequest_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16692,6 +17347,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGlobalMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGlobalMessage_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16717,6 +17373,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMapMove_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pMapMove_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16742,6 +17399,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeDir_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pChangeDir_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16767,6 +17425,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEmotion_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pEmotion_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16792,6 +17451,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHowManyConnections_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pHowManyConnections_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16817,6 +17477,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pActionRequest_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16842,6 +17503,7 @@ void HP_clif_pActionRequest_sub(struct map_session_data *sd, int action_type, in
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pActionRequest_sub_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *action_type, int *target_id, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -16867,6 +17529,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRestart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pRestart_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16892,6 +17555,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWisMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pWisMessage_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16917,6 +17581,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBroadcast_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBroadcast_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16942,6 +17607,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTakeItem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTakeItem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16967,6 +17633,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDropItem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pDropItem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -16992,6 +17659,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseItem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pUseItem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17017,6 +17685,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipItem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pEquipItem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17042,6 +17711,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUnequipItem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pUnequipItem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17067,6 +17737,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcClicked_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcClicked_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17092,6 +17763,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuySellSelected_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcBuySellSelected_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17117,6 +17789,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuyListSend_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcBuyListSend_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17142,6 +17815,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSellListSend_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcSellListSend_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17167,6 +17841,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateChatRoom_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCreateChatRoom_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17192,6 +17867,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatAddMember_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pChatAddMember_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17217,6 +17893,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatRoomStatusChange_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pChatRoomStatusChange_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17242,6 +17919,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeChatOwner_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pChangeChatOwner_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17267,6 +17945,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pKickFromChat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pKickFromChat_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17292,6 +17971,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatLeave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pChatLeave_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17317,6 +17997,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeRequest_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTradeRequest_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17342,6 +18023,7 @@ void HP_clif_chann_config_read(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_chann_config_read_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -17367,6 +18049,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTradeAck_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17392,6 +18075,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAddItem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTradeAddItem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17417,6 +18101,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeOk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTradeOk_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17442,6 +18127,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCancel_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTradeCancel_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17467,6 +18153,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCommit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTradeCommit_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17492,6 +18179,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStopAttack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pStopAttack_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17517,6 +18205,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPutItemToCart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPutItemToCart_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17542,6 +18231,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetItemFromCart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGetItemFromCart_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17567,6 +18257,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemoveOption_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pRemoveOption_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17592,6 +18283,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeCart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pChangeCart_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17617,6 +18309,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStatusUp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pStatusUp_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17642,6 +18335,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillUp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSkillUp_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17667,6 +18361,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17692,6 +18387,7 @@ void HP_clif_pUseSkillToId_homun(struct homun_data *hd, struct map_session_data
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pUseSkillToId_homun_pre ) {
 		void (*preHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id);
+		*HPMforce_return = false;
 		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);
@@ -17717,6 +18413,7 @@ void HP_clif_pUseSkillToId_mercenary(struct mercenary_data *md, struct map_sessi
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pUseSkillToId_mercenary_pre ) {
 		void (*preHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, int *target_id);
+		*HPMforce_return = false;
 		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);
@@ -17742,6 +18439,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17767,6 +18465,7 @@ void HP_clif_pUseSkillToPosSub(int fd, struct map_session_data *sd, uint16 skill
 	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);
+		*HPMforce_return = false;
 		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);
@@ -17792,6 +18491,7 @@ void HP_clif_pUseSkillToPos_homun(struct homun_data *hd, struct map_session_data
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pUseSkillToPos_homun_pre ) {
 		void (*preHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo);
+		*HPMforce_return = false;
 		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);
@@ -17817,6 +18517,7 @@ void HP_clif_pUseSkillToPos_mercenary(struct mercenary_data *md, struct map_sess
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_pre ) {
 		void (*preHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 *tick, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *skillmoreinfo);
+		*HPMforce_return = false;
 		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);
@@ -17842,6 +18543,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosMoreInfo_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17867,6 +18569,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillMap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pUseSkillMap_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17892,6 +18595,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRequestMemo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pRequestMemo_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17917,6 +18621,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProduceMix_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pProduceMix_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17942,6 +18647,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCooking_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCooking_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17967,6 +18673,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRepairItem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pRepairItem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -17992,6 +18699,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWeaponRefine_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pWeaponRefine_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18017,6 +18725,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSelectMenu_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcSelectMenu_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18042,6 +18751,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcNextClicked_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcNextClicked_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18067,6 +18777,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcAmountInput_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcAmountInput_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18092,6 +18803,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcStringInput_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcStringInput_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18117,6 +18829,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcCloseClicked_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNpcCloseClicked_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18142,6 +18855,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemIdentify_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pItemIdentify_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18167,6 +18881,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectArrow_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSelectArrow_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18192,6 +18907,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoSpell_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pAutoSpell_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18217,6 +18933,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseCard_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pUseCard_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18242,6 +18959,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pInsertCard_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pInsertCard_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18267,6 +18985,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSolveCharName_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSolveCharName_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18292,6 +19011,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pResetChar_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pResetChar_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18317,6 +19037,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLocalBroadcast_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pLocalBroadcast_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18342,6 +19063,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafra_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pMoveToKafra_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18367,6 +19089,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafra_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pMoveFromKafra_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18392,6 +19115,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafraFromCart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pMoveToKafraFromCart_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18417,6 +19141,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafraToCart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pMoveFromKafraToCart_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18442,6 +19167,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseKafra_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCloseKafra_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18467,6 +19193,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStoragePassword_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pStoragePassword_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18492,6 +19219,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCreateParty_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18517,6 +19245,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCreateParty2_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18542,6 +19271,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyInvite_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18567,6 +19297,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyInvite2_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18592,6 +19323,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18617,6 +19349,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite2_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18642,6 +19375,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLeaveParty_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pLeaveParty_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18667,6 +19401,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemovePartyMember_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pRemovePartyMember_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18692,6 +19427,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeOption_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyChangeOption_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18717,6 +19453,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyMessage_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18742,6 +19479,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeLeader_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyChangeLeader_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18767,6 +19505,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRegisterReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingRegisterReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18792,6 +19531,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSearchReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingSearchReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18817,6 +19557,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingDeleteReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingDeleteReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18842,6 +19583,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingUpdateReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingUpdateReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18867,6 +19609,7 @@ void HP_clif_pPartyRecruitRegisterReq(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pPartyRecruitRegisterReq_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitRegisterReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyRecruitRegisterReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18892,6 +19635,7 @@ void HP_clif_pPartyRecruitSearchReq(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pPartyRecruitSearchReq_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitSearchReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyRecruitSearchReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18917,6 +19661,7 @@ void HP_clif_pPartyRecruitDeleteReq(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pPartyRecruitDeleteReq_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitDeleteReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyRecruitDeleteReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18942,6 +19687,7 @@ void HP_clif_pPartyRecruitUpdateReq(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pPartyRecruitUpdateReq_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitUpdateReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyRecruitUpdateReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18967,6 +19713,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseVending_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCloseVending_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -18992,6 +19739,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pVendingListReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pVendingListReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19017,6 +19765,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPurchaseReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19042,6 +19791,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPurchaseReq2_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19067,6 +19817,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOpenVending_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pOpenVending_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19092,6 +19843,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateGuild_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCreateGuild_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19117,6 +19869,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildCheckMaster_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildCheckMaster_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19142,6 +19895,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildRequestInfo_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19167,6 +19921,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangePositionInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildChangePositionInfo_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19192,6 +19947,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeMemberPosition_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildChangeMemberPosition_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19217,6 +19973,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestEmblem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildRequestEmblem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19242,6 +19999,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeEmblem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildChangeEmblem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19267,6 +20025,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeNotice_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildChangeNotice_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19292,6 +20051,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildInvite_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19317,6 +20077,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyInvite_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildReplyInvite_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19342,6 +20103,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildLeave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildLeave_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19367,6 +20129,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildExpulsion_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildExpulsion_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19392,6 +20155,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildMessage_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19417,6 +20181,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestAlliance_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildRequestAlliance_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19442,6 +20207,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyAlliance_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildReplyAlliance_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19467,6 +20233,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildDelAlliance_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildDelAlliance_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19492,6 +20259,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildOpposition_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildOpposition_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19517,6 +20285,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildBreak_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildBreak_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19542,6 +20311,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPetMenu_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPetMenu_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19567,6 +20337,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCatchPet_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCatchPet_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19592,6 +20363,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectEgg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSelectEgg_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19617,6 +20389,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSendEmotion_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSendEmotion_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19642,6 +20415,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangePetName_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pChangePetName_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19667,6 +20441,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKick_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMKick_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19692,6 +20467,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKickAll_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMKickAll_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19717,6 +20493,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMShift_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMShift_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19742,6 +20519,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRemove2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMRemove2_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19767,6 +20545,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMRecall_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19792,6 +20571,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMRecall2_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19817,6 +20597,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -19842,6 +20623,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMHide_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMHide_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19867,6 +20649,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqNoChat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMReqNoChat_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19892,6 +20675,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMRc_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19917,6 +20701,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqAccountName_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMReqAccountName_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19942,6 +20727,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMChangeMapType_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMChangeMapType_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19967,6 +20753,7 @@ void HP_clif_pGMFullStrip(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pGMFullStrip_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMFullStrip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGMFullStrip_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -19992,6 +20779,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnore_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPMIgnore_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20017,6 +20805,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreAll_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPMIgnoreAll_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20042,6 +20831,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreList_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPMIgnoreList_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20067,6 +20857,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceDoriDori_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNoviceDoriDori_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20092,6 +20883,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceExplosionSpirits_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNoviceExplosionSpirits_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20117,6 +20909,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListAdd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pFriendsListAdd_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20142,6 +20935,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListReply_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pFriendsListReply_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20167,6 +20961,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListRemove_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pFriendsListRemove_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20192,6 +20987,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPVPInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPVPInfo_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20217,6 +21013,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBlacksmith_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBlacksmith_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20242,6 +21039,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAlchemist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pAlchemist_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20267,6 +21065,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTaekwon_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pTaekwon_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20292,6 +21091,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRankingPk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pRankingPk_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20317,6 +21117,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFeelSaveOk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pFeelSaveOk_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20342,6 +21143,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeHomunculusName_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pChangeHomunculusName_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20367,6 +21169,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveToMaster_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pHomMoveToMaster_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20392,6 +21195,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveTo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pHomMoveTo_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20417,6 +21221,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomAttack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pHomAttack_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20442,6 +21247,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMenu_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pHomMenu_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20467,6 +21273,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoRevive_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pAutoRevive_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20492,6 +21299,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCheck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCheck_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -20517,6 +21325,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20542,6 +21351,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20567,6 +21377,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20592,6 +21403,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20617,6 +21429,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20642,6 +21455,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20667,6 +21481,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20692,6 +21507,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20717,6 +21533,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20742,6 +21559,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20767,6 +21585,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20792,6 +21611,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20817,6 +21637,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20842,6 +21663,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20867,6 +21689,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20892,6 +21715,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20917,6 +21741,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20942,6 +21767,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20967,6 +21793,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -20992,6 +21819,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pViewPlayerEquip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pViewPlayerEquip_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21017,6 +21845,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipTick_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pEquipTick_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21042,6 +21871,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pquestStateAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pquestStateAck_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21067,6 +21897,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -21092,6 +21923,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBattleChat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBattleChat_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21117,6 +21949,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLessEffect_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pLessEffect_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21142,6 +21975,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemListWindowSelected_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pItemListWindowSelected_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21167,6 +22001,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqOpenBuyingStore_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pReqOpenBuyingStore_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21192,6 +22027,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqCloseBuyingStore_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pReqCloseBuyingStore_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21217,6 +22053,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqClickBuyingStore_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pReqClickBuyingStore_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21242,6 +22079,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqTradeBuyingStore_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pReqTradeBuyingStore_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21267,6 +22105,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfo_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21292,6 +22131,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoNextPage_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21317,6 +22157,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseSearchStoreInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCloseSearchStoreInfo_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21342,6 +22183,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoListItemClick_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21367,6 +22209,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDebug_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pDebug_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21392,6 +22235,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillSelectMenu_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pSkillSelectMenu_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21417,6 +22261,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveItem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pMoveItem_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21442,6 +22287,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDull_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pDull_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21467,6 +22313,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRegister_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBGQueueRegister_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21492,6 +22339,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueCheckState_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBGQueueCheckState_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21517,6 +22365,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRevokeReq_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBGQueueRevokeReq_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21542,6 +22391,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBGQueueBattleBeginAck_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21567,6 +22417,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopOpen_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCashShopOpen_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21592,6 +22443,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopClose_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCashShopClose_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21617,6 +22469,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopReqTab_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCashShopReqTab_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21642,6 +22495,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopSchedule_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCashShopSchedule_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21667,6 +22521,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopBuy_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pCashShopBuy_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21692,6 +22547,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyTick_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyTick_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21717,6 +22573,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pGuildInvite2_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21742,6 +22599,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingAddFilter_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingAddFilter_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21767,6 +22625,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSubFilter_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingSubFilter_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21792,6 +22651,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingReqVolunteer_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21817,6 +22677,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingRefuseVolunteer_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21842,6 +22703,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pPartyBookingCancelVolunteer_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21867,6 +22729,7 @@ void HP_clif_pBankDeposit(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pBankDeposit_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankDeposit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBankDeposit_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21892,6 +22755,7 @@ void HP_clif_pBankWithdraw(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pBankWithdraw_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankWithdraw_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBankWithdraw_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21917,6 +22781,7 @@ void HP_clif_pBankCheck(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pBankCheck_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankCheck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBankCheck_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21942,6 +22807,7 @@ void HP_clif_pBankOpen(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pBankOpen_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankOpen_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBankOpen_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21967,6 +22833,7 @@ void HP_clif_pBankClose(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pBankClose_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankClose_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pBankClose_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -21992,6 +22859,7 @@ void HP_clif_pNPCShopClosed(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pNPCShopClosed_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCShopClosed_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNPCShopClosed_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -22017,6 +22885,7 @@ void HP_clif_pNPCMarketClosed(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pNPCMarketClosed_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCMarketClosed_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNPCMarketClosed_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -22042,6 +22911,7 @@ void HP_clif_pNPCMarketPurchase(int fd, struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_clif_pNPCMarketPurchase_pre ) {
 		void (*preHookFunc) (int *fd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCMarketPurchase_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_clif_pNPCMarketPurchase_pre[hIndex].func;
 			preHookFunc(&fd, sd);
@@ -22069,6 +22939,7 @@ int HP_duel_create(struct map_session_data *sd, const unsigned int maxpl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_duel_create_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, const unsigned int *maxpl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_create_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_duel_create_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &maxpl);
@@ -22094,6 +22965,7 @@ void HP_duel_invite(const unsigned int did, struct map_session_data *sd, struct
 	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);
+		*HPMforce_return = false;
 		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);
@@ -22119,6 +22991,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_accept_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_duel_accept_pre[hIndex].func;
 			preHookFunc(&did, sd);
@@ -22144,6 +23017,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_reject_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_duel_reject_pre[hIndex].func;
 			preHookFunc(&did, sd);
@@ -22169,6 +23043,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_leave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_duel_leave_pre[hIndex].func;
 			preHookFunc(&did, sd);
@@ -22194,6 +23069,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_showinfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_duel_showinfo_pre[hIndex].func;
 			preHookFunc(&did, sd);
@@ -22220,6 +23096,7 @@ int HP_duel_checktime(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_duel_checktime_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_checktime_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_duel_checktime_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -22245,6 +23122,7 @@ void HP_duel_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_duel_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_duel_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -22270,6 +23148,7 @@ void HP_duel_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_duel_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_duel_final_pre[hIndex].func;
 			preHookFunc();
@@ -22297,6 +23176,7 @@ int HP_elemental_init(bool minimal) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_init_pre ) {
 		int (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_init_pre[hIndex].func;
 			retVal___ = preHookFunc(&minimal);
@@ -22322,6 +23202,7 @@ void HP_elemental_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_elemental_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_final_pre[hIndex].func;
 			preHookFunc();
@@ -22348,6 +23229,7 @@ bool HP_elemental_class(int class_) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_elemental_class_pre ) {
 		bool (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_class_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_class_pre[hIndex].func;
 			retVal___ = preHookFunc(&class_);
@@ -22374,6 +23256,7 @@ struct view_data* HP_elemental_get_viewdata(int class_) {
 	struct view_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_elemental_get_viewdata_pre ) {
 		struct view_data* (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -22400,6 +23283,7 @@ int HP_elemental_create(struct map_session_data *sd, int class_, unsigned int li
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_create_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *class_, unsigned int *lifetime);
+		*HPMforce_return = false;
 		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);
@@ -22426,6 +23310,7 @@ int HP_elemental_data_received(struct s_elemental *ele, bool flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_data_received_pre ) {
 		int (*preHookFunc) (struct s_elemental *ele, bool *flag);
+		*HPMforce_return = false;
 		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);
@@ -22452,6 +23337,7 @@ int HP_elemental_save(struct elemental_data *ed) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_save_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_save_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_save_pre[hIndex].func;
 			retVal___ = preHookFunc(ed);
@@ -22478,6 +23364,7 @@ int HP_elemental_change_mode_ack(struct elemental_data *ed, int mode) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_change_mode_ack_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed, int *mode);
+		*HPMforce_return = false;
 		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);
@@ -22504,6 +23391,7 @@ int HP_elemental_change_mode(struct elemental_data *ed, int mode) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_change_mode_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed, int *mode);
+		*HPMforce_return = false;
 		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);
@@ -22529,6 +23417,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_heal_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_heal_pre[hIndex].func;
 			preHookFunc(ed, &hp, &sp);
@@ -22555,6 +23444,7 @@ int HP_elemental_dead(struct elemental_data *ed) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_dead_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_dead_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_dead_pre[hIndex].func;
 			retVal___ = preHookFunc(ed);
@@ -22581,6 +23471,7 @@ int HP_elemental_delete(struct elemental_data *ed, int reply) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_delete_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed, int *reply);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_delete_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_delete_pre[hIndex].func;
 			retVal___ = preHookFunc(ed, &reply);
@@ -22606,6 +23497,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_stop_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_summon_stop_pre[hIndex].func;
 			preHookFunc(ed);
@@ -22632,6 +23524,7 @@ int HP_elemental_get_lifetime(struct elemental_data *ed) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_get_lifetime_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed);
+		*HPMforce_return = false;
 		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);
@@ -22658,6 +23551,7 @@ int HP_elemental_unlocktarget(struct elemental_data *ed) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_unlocktarget_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_unlocktarget_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_unlocktarget_pre[hIndex].func;
 			retVal___ = preHookFunc(ed);
@@ -22684,6 +23578,7 @@ int HP_elemental_skillnotok(uint16 skill_id, struct elemental_data *ed) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_skillnotok_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, struct elemental_data *ed);
+		*HPMforce_return = false;
 		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);
@@ -22710,6 +23605,7 @@ int HP_elemental_set_target(struct map_session_data *sd, struct block_list *bl)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_set_target_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -22736,6 +23632,7 @@ int HP_elemental_clean_single_effect(struct elemental_data *ed, uint16 skill_id)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_clean_single_effect_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -22762,6 +23659,7 @@ int HP_elemental_clean_effect(struct elemental_data *ed) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_clean_effect_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed);
+		*HPMforce_return = false;
 		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);
@@ -22788,6 +23686,7 @@ int HP_elemental_action(struct elemental_data *ed, struct block_list *bl, int64
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_action_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed, struct block_list *bl, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -22815,6 +23714,7 @@ struct skill_condition HP_elemental_skill_get_requirements(uint16 skill_id, uint
 	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);
+		*HPMforce_return = false;
 		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);
@@ -22841,6 +23741,7 @@ int HP_elemental_read_skilldb(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_read_skilldb_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_read_skilldb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_read_skilldb_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -22866,6 +23767,7 @@ void HP_elemental_reload_db(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_elemental_reload_db_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_reload_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_reload_db_pre[hIndex].func;
 			preHookFunc();
@@ -22891,6 +23793,7 @@ void HP_elemental_reload_skilldb(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_elemental_reload_skilldb_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_reload_skilldb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_reload_skilldb_pre[hIndex].func;
 			preHookFunc();
@@ -22917,6 +23820,7 @@ int HP_elemental_search_index(int class_) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_search_index_pre ) {
 		int (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -22942,6 +23846,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_summon_init_pre[hIndex].func;
 			preHookFunc(ed);
@@ -22968,6 +23873,7 @@ int HP_elemental_summon_end_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_summon_end_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -22994,6 +23900,7 @@ int HP_elemental_ai_sub_timer_activesearch(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -23026,6 +23933,7 @@ int HP_elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_data
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_ai_sub_timer_pre ) {
 		int (*preHookFunc) (struct elemental_data *ed, struct map_session_data *sd, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -23052,6 +23960,7 @@ int HP_elemental_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_ai_sub_foreachclient_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -23084,6 +23993,7 @@ int HP_elemental_ai_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_ai_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -23110,6 +24020,7 @@ int HP_elemental_read_db(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_elemental_read_db_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_read_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_elemental_read_db_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -23136,6 +24047,7 @@ void HP_guild_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -23161,6 +24073,7 @@ void HP_guild_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_final_pre[hIndex].func;
 			preHookFunc();
@@ -23187,6 +24100,7 @@ int HP_guild_skill_get_max(int id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_skill_get_max_pre ) {
 		int (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		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);
@@ -23213,6 +24127,7 @@ int HP_guild_checkskill(struct guild *g, int id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_checkskill_pre ) {
 		int (*preHookFunc) (struct guild *g, int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkskill_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_checkskill_pre[hIndex].func;
 			retVal___ = preHookFunc(g, &id);
@@ -23239,6 +24154,7 @@ int HP_guild_check_skill_require(struct guild *g, int id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_check_skill_require_pre ) {
 		int (*preHookFunc) (struct guild *g, int *id);
+		*HPMforce_return = false;
 		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);
@@ -23265,6 +24181,7 @@ int HP_guild_checkcastles(struct guild *g) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_checkcastles_pre ) {
 		int (*preHookFunc) (struct guild *g);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkcastles_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_checkcastles_pre[hIndex].func;
 			retVal___ = preHookFunc(g);
@@ -23291,6 +24208,7 @@ bool HP_guild_isallied(int guild_id, int guild_id2) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_guild_isallied_pre ) {
 		bool (*preHookFunc) (int *guild_id, int *guild_id2);
+		*HPMforce_return = false;
 		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);
@@ -23317,6 +24235,7 @@ struct guild* HP_guild_search(int guild_id) {
 	struct guild* retVal___ = NULL;
 	if( HPMHooks.count.HP_guild_search_pre ) {
 		struct guild* (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_search_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_search_pre[hIndex].func;
 			retVal___ = preHookFunc(&guild_id);
@@ -23343,6 +24262,7 @@ struct guild* HP_guild_searchname(char *str) {
 	struct guild* retVal___ = NULL;
 	if( HPMHooks.count.HP_guild_searchname_pre ) {
 		struct guild* (*preHookFunc) (char *str);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_searchname_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_searchname_pre[hIndex].func;
 			retVal___ = preHookFunc(str);
@@ -23369,6 +24289,7 @@ struct guild_castle* HP_guild_castle_search(int gcid) {
 	struct guild_castle* retVal___ = NULL;
 	if( HPMHooks.count.HP_guild_castle_search_pre ) {
 		struct guild_castle* (*preHookFunc) (int *gcid);
+		*HPMforce_return = false;
 		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);
@@ -23395,6 +24316,7 @@ struct guild_castle* HP_guild_mapname2gc(const char *mapname) {
 	struct guild_castle* retVal___ = NULL;
 	if( HPMHooks.count.HP_guild_mapname2gc_pre ) {
 		struct guild_castle* (*preHookFunc) (const char *mapname);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapname2gc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_mapname2gc_pre[hIndex].func;
 			retVal___ = preHookFunc(mapname);
@@ -23421,6 +24343,7 @@ struct guild_castle* HP_guild_mapindex2gc(short map_index) {
 	struct guild_castle* retVal___ = NULL;
 	if( HPMHooks.count.HP_guild_mapindex2gc_pre ) {
 		struct guild_castle* (*preHookFunc) (short *map_index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapindex2gc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_mapindex2gc_pre[hIndex].func;
 			retVal___ = preHookFunc(&map_index);
@@ -23447,6 +24370,7 @@ struct map_session_data* HP_guild_getavailablesd(struct guild *g) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_guild_getavailablesd_pre ) {
 		struct map_session_data* (*preHookFunc) (struct guild *g);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getavailablesd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_getavailablesd_pre[hIndex].func;
 			retVal___ = preHookFunc(g);
@@ -23473,6 +24397,7 @@ int HP_guild_getindex(struct guild *g, int account_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_getindex_pre ) {
 		int (*preHookFunc) (struct guild *g, int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -23499,6 +24424,7 @@ int HP_guild_getposition(struct guild *g, struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_getposition_pre ) {
 		int (*preHookFunc) (struct guild *g, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getposition_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_getposition_pre[hIndex].func;
 			retVal___ = preHookFunc(g, sd);
@@ -23525,6 +24451,7 @@ unsigned int HP_guild_payexp(struct map_session_data *sd, unsigned int exp) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_payexp_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd, unsigned int *exp);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_payexp_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &exp);
@@ -23551,6 +24478,7 @@ int HP_guild_getexp(struct map_session_data *sd, int exp) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_getexp_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *exp);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getexp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_getexp_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &exp);
@@ -23577,6 +24505,7 @@ int HP_guild_create(struct map_session_data *sd, const char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_create_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_create_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, name);
@@ -23603,6 +24532,7 @@ int HP_guild_created(int account_id, int guild_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_created_pre ) {
 		int (*preHookFunc) (int *account_id, int *guild_id);
+		*HPMforce_return = false;
 		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);
@@ -23629,6 +24559,7 @@ int HP_guild_request_info(int guild_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_request_info_pre ) {
 		int (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		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);
@@ -23655,6 +24586,7 @@ int HP_guild_recv_noinfo(int guild_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_recv_noinfo_pre ) {
 		int (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		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);
@@ -23681,6 +24613,7 @@ int HP_guild_recv_info(struct guild *sg) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_recv_info_pre ) {
 		int (*preHookFunc) (struct guild *sg);
+		*HPMforce_return = false;
 		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);
@@ -23707,6 +24640,7 @@ int HP_guild_npc_request_info(int guild_id, const char *ev) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_npc_request_info_pre ) {
 		int (*preHookFunc) (int *guild_id, const char *ev);
+		*HPMforce_return = false;
 		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);
@@ -23733,6 +24667,7 @@ int HP_guild_invite(struct map_session_data *sd, struct map_session_data *tsd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_invite_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_invite_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_invite_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, tsd);
@@ -23759,6 +24694,7 @@ int HP_guild_reply_invite(struct map_session_data *sd, int guild_id, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_reply_invite_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -23784,6 +24720,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_joined_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_member_joined_pre[hIndex].func;
 			preHookFunc(sd);
@@ -23810,6 +24747,7 @@ int HP_guild_member_added(int guild_id, int account_id, int char_id, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_member_added_pre ) {
 		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -23836,6 +24774,7 @@ int HP_guild_leave(struct map_session_data *sd, int guild_id, int account_id, in
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -23862,6 +24801,7 @@ int HP_guild_member_withdraw(int guild_id, int account_id, int char_id, int flag
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -23888,6 +24828,7 @@ int HP_guild_expulsion(struct map_session_data *sd, int guild_id, int account_id
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -23914,6 +24855,7 @@ int HP_guild_skillup(struct map_session_data *sd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_skillup_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -23939,6 +24881,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -23965,6 +24908,7 @@ int HP_guild_reqalliance(struct map_session_data *sd, struct map_session_data *t
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_reqalliance_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reqalliance_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_reqalliance_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, tsd);
@@ -23991,6 +24935,7 @@ int HP_guild_reply_reqalliance(struct map_session_data *sd, int account_id, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_reply_reqalliance_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *account_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -24017,6 +24962,7 @@ int HP_guild_allianceack(int guild_id1, int guild_id2, int account_id1, int acco
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -24043,6 +24989,7 @@ int HP_guild_delalliance(struct map_session_data *sd, int guild_id, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_delalliance_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *guild_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -24069,6 +25016,7 @@ int HP_guild_opposition(struct map_session_data *sd, struct map_session_data *ts
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_opposition_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_opposition_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_opposition_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, tsd);
@@ -24095,6 +25043,7 @@ int HP_guild_check_alliance(int guild_id1, int guild_id2, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_check_alliance_pre ) {
 		int (*preHookFunc) (int *guild_id1, int *guild_id2, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -24121,6 +25070,7 @@ int HP_guild_send_memberinfoshort(struct map_session_data *sd, int online) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_send_memberinfoshort_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *online);
+		*HPMforce_return = false;
 		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);
@@ -24147,6 +25097,7 @@ int HP_guild_recv_memberinfoshort(int guild_id, int account_id, int char_id, int
 	int retVal___ = 0;
 	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_);
+		*HPMforce_return = false;
 		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_);
@@ -24173,6 +25124,7 @@ int HP_guild_change_memberposition(int guild_id, int account_id, int char_id, sh
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_change_memberposition_pre ) {
 		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, short *idx);
+		*HPMforce_return = false;
 		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);
@@ -24199,6 +25151,7 @@ int HP_guild_memberposition_changed(struct guild *g, int idx, int pos) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_memberposition_changed_pre ) {
 		int (*preHookFunc) (struct guild *g, int *idx, int *pos);
+		*HPMforce_return = false;
 		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);
@@ -24225,6 +25178,7 @@ int HP_guild_change_position(int guild_id, int idx, int mode, int exp_mode, cons
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_change_position_pre ) {
 		int (*preHookFunc) (int *guild_id, int *idx, int *mode, int *exp_mode, const char *name);
+		*HPMforce_return = false;
 		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);
@@ -24251,6 +25205,7 @@ int HP_guild_position_changed(int guild_id, int idx, struct guild_position *p) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_position_changed_pre ) {
 		int (*preHookFunc) (int *guild_id, int *idx, struct guild_position *p);
+		*HPMforce_return = false;
 		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);
@@ -24277,6 +25232,7 @@ int HP_guild_change_notice(struct map_session_data *sd, int guild_id, const char
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_change_notice_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *guild_id, const char *mes1, const char *mes2);
+		*HPMforce_return = false;
 		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);
@@ -24303,6 +25259,7 @@ int HP_guild_notice_changed(int guild_id, const char *mes1, const char *mes2) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_notice_changed_pre ) {
 		int (*preHookFunc) (int *guild_id, const char *mes1, const char *mes2);
+		*HPMforce_return = false;
 		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);
@@ -24329,6 +25286,7 @@ int HP_guild_change_emblem(struct map_session_data *sd, int len, const char *dat
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_change_emblem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *len, const char *data);
+		*HPMforce_return = false;
 		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);
@@ -24355,6 +25313,7 @@ int HP_guild_emblem_changed(int len, int guild_id, int emblem_id, const char *da
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_emblem_changed_pre ) {
 		int (*preHookFunc) (int *len, int *guild_id, int *emblem_id, const char *data);
+		*HPMforce_return = false;
 		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);
@@ -24381,6 +25340,7 @@ int HP_guild_send_message(struct map_session_data *sd, const char *mes, int len)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_send_message_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len);
+		*HPMforce_return = false;
 		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);
@@ -24407,6 +25367,7 @@ int HP_guild_recv_message(int guild_id, int account_id, const char *mes, int len
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_recv_message_pre ) {
 		int (*preHookFunc) (int *guild_id, int *account_id, const char *mes, int *len);
+		*HPMforce_return = false;
 		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);
@@ -24433,6 +25394,7 @@ int HP_guild_send_dot_remove(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_send_dot_remove_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -24459,6 +25421,7 @@ int HP_guild_skillupack(int guild_id, uint16 skill_id, int account_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_skillupack_pre ) {
 		int (*preHookFunc) (int *guild_id, uint16 *skill_id, int *account_id);
+		*HPMforce_return = false;
 		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);
@@ -24485,6 +25448,7 @@ int HP_guild_dobreak(struct map_session_data *sd, char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_dobreak_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_dobreak_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_dobreak_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, name);
@@ -24511,6 +25475,7 @@ int HP_guild_broken(int guild_id, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_broken_pre ) {
 		int (*preHookFunc) (int *guild_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -24537,6 +25502,7 @@ int HP_guild_gm_change(int guild_id, struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_gm_change_pre ) {
 		int (*preHookFunc) (int *guild_id, struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -24563,6 +25529,7 @@ int HP_guild_gm_changed(int guild_id, int account_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_gm_changed_pre ) {
 		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -24588,6 +25555,7 @@ void HP_guild_castle_map_init(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_castle_map_init_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -24614,6 +25582,7 @@ int HP_guild_castledatasave(int castle_id, int index, int value) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_castledatasave_pre ) {
 		int (*preHookFunc) (int *castle_id, int *index, int *value);
+		*HPMforce_return = false;
 		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);
@@ -24640,6 +25609,7 @@ int HP_guild_castledataloadack(int len, struct guild_castle *gc) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_castledataloadack_pre ) {
 		int (*preHookFunc) (int *len, struct guild_castle *gc);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledataloadack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_castledataloadack_pre[hIndex].func;
 			retVal___ = preHookFunc(&len, gc);
@@ -24665,6 +25635,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -24690,6 +25661,7 @@ void HP_guild_agit_start(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_agit_start_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit_start_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_agit_start_pre[hIndex].func;
 			preHookFunc();
@@ -24715,6 +25687,7 @@ void HP_guild_agit_end(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_agit_end_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit_end_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_agit_end_pre[hIndex].func;
 			preHookFunc();
@@ -24740,6 +25713,7 @@ void HP_guild_agit2_start(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_agit2_start_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit2_start_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_agit2_start_pre[hIndex].func;
 			preHookFunc();
@@ -24765,6 +25739,7 @@ void HP_guild_agit2_end(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_agit2_end_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit2_end_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_agit2_end_pre[hIndex].func;
 			preHookFunc();
@@ -24790,6 +25765,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_add_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_flag_add_pre[hIndex].func;
 			preHookFunc(nd);
@@ -24815,6 +25791,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_remove_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_flag_remove_pre[hIndex].func;
 			preHookFunc(nd);
@@ -24840,6 +25817,7 @@ void HP_guild_flags_clear(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_flags_clear_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flags_clear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_flags_clear_pre[hIndex].func;
 			preHookFunc();
@@ -24865,6 +25843,7 @@ void HP_guild_aura_refresh(struct map_session_data *sd, uint16 skill_id, uint16
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_aura_refresh_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -24890,6 +25869,7 @@ void HP_guild_retrieveitembound(int char_id, int aid, int guild_id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_guild_retrieveitembound_pre ) {
 		void (*preHookFunc) (int *char_id, int *aid, int *guild_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_retrieveitembound_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_retrieveitembound_pre[hIndex].func;
 			preHookFunc(&char_id, &aid, &guild_id);
@@ -24916,6 +25896,7 @@ int HP_guild_payexp_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_payexp_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -24942,6 +25923,7 @@ TBL_PC* HP_guild_sd_check(int guild_id, int account_id, int char_id) {
 	TBL_PC* retVal___ = NULL;
 	if( HPMHooks.count.HP_guild_sd_check_pre ) {
 		TBL_PC* (*preHookFunc) (int *guild_id, int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -24968,6 +25950,7 @@ bool HP_guild_read_guildskill_tree_db(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_guild_read_guildskill_tree_db_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -24994,6 +25977,7 @@ bool HP_guild_read_castledb(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_guild_read_castledb_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -25020,6 +26004,7 @@ int HP_guild_payexp_timer_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_payexp_timer_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -25052,6 +26037,7 @@ int HP_guild_send_xy_timer_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_send_xy_timer_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -25084,6 +26070,7 @@ int HP_guild_send_xy_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_send_xy_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -25111,6 +26098,7 @@ DBData HP_guild_create_expcache(DBKey key, va_list args) {
 	memset(&retVal___, '\0', sizeof(DBData));
 	if( HPMHooks.count.HP_guild_create_expcache_pre ) {
 		DBData (*preHookFunc) (DBKey *key, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -25143,6 +26131,7 @@ int HP_guild_eventlist_db_final(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_eventlist_db_final_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -25175,6 +26164,7 @@ int HP_guild_expcache_db_final(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_expcache_db_final_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -25207,6 +26197,7 @@ int HP_guild_castle_db_final(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_castle_db_final_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -25239,6 +26230,7 @@ int HP_guild_broken_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_broken_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -25271,6 +26263,7 @@ int HP_guild_castle_broken_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_castle_broken_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -25302,6 +26295,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_makemember_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_guild_makemember_pre[hIndex].func;
 			preHookFunc(m, sd);
@@ -25328,6 +26322,7 @@ int HP_guild_check_member(struct guild *g) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_check_member_pre ) {
 		int (*preHookFunc) (struct guild *g);
+		*HPMforce_return = false;
 		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);
@@ -25354,6 +26349,7 @@ int HP_guild_get_alliance_count(struct guild *g, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_guild_get_alliance_count_pre ) {
 		int (*preHookFunc) (struct guild *g, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -25379,6 +26375,7 @@ 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);
+		*HPMforce_return = false;
 		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;
@@ -25412,6 +26409,7 @@ struct guild_storage* HP_gstorage_id2storage(int guild_id) {
 	struct guild_storage* retVal___ = NULL;
 	if( HPMHooks.count.HP_gstorage_id2storage_pre ) {
 		struct guild_storage* (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_id2storage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_gstorage_id2storage_pre[hIndex].func;
 			retVal___ = preHookFunc(&guild_id);
@@ -25438,6 +26436,7 @@ struct guild_storage* HP_gstorage_id2storage2(int guild_id) {
 	struct guild_storage* retVal___ = NULL;
 	if( HPMHooks.count.HP_gstorage_id2storage2_pre ) {
 		struct guild_storage* (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_id2storage2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_gstorage_id2storage2_pre[hIndex].func;
 			retVal___ = preHookFunc(&guild_id);
@@ -25463,6 +26462,7 @@ void HP_gstorage_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_gstorage_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_gstorage_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -25488,6 +26488,7 @@ void HP_gstorage_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_gstorage_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_gstorage_final_pre[hIndex].func;
 			preHookFunc();
@@ -25514,6 +26515,7 @@ int HP_gstorage_delete(int guild_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_delete_pre ) {
 		int (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delete_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_gstorage_delete_pre[hIndex].func;
 			retVal___ = preHookFunc(&guild_id);
@@ -25540,6 +26542,7 @@ int HP_gstorage_open(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_open_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_open_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_gstorage_open_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -25566,6 +26569,7 @@ int HP_gstorage_additem(struct map_session_data *sd, struct guild_storage *stor,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_additem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -25592,6 +26596,7 @@ int HP_gstorage_delitem(struct map_session_data *sd, struct guild_storage *stor,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_delitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct guild_storage *stor, int *n, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -25618,6 +26623,7 @@ int HP_gstorage_add(struct map_session_data *sd, int index, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_add_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -25644,6 +26650,7 @@ int HP_gstorage_get(struct map_session_data *sd, int index, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_get_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -25670,6 +26677,7 @@ int HP_gstorage_addfromcart(struct map_session_data *sd, int index, int amount)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_addfromcart_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -25696,6 +26704,7 @@ int HP_gstorage_gettocart(struct map_session_data *sd, int index, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_gettocart_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -25722,6 +26731,7 @@ int HP_gstorage_close(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_close_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_close_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_gstorage_close_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -25748,6 +26758,7 @@ int HP_gstorage_pc_quit(struct map_session_data *sd, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_pc_quit_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -25774,6 +26785,7 @@ int HP_gstorage_save(int account_id, int guild_id, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_save_pre ) {
 		int (*preHookFunc) (int *account_id, int *guild_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -25800,6 +26812,7 @@ int HP_gstorage_saved(int guild_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_gstorage_saved_pre ) {
 		int (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_saved_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_gstorage_saved_pre[hIndex].func;
 			retVal___ = preHookFunc(&guild_id);
@@ -25827,6 +26840,7 @@ DBData HP_gstorage_create(DBKey key, va_list args) {
 	memset(&retVal___, '\0', sizeof(DBData));
 	if( HPMHooks.count.HP_gstorage_create_pre ) {
 		DBData (*preHookFunc) (DBKey *key, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -25859,6 +26873,7 @@ void HP_homun_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -25884,6 +26899,7 @@ void HP_homun_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_final_pre[hIndex].func;
 			preHookFunc();
@@ -25909,6 +26925,7 @@ void HP_homun_reload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_reload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_reload_pre[hIndex].func;
 			preHookFunc();
@@ -25934,6 +26951,7 @@ void HP_homun_reload_skill(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_reload_skill_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_skill_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_reload_skill_pre[hIndex].func;
 			preHookFunc();
@@ -25960,6 +26978,7 @@ struct view_data* HP_homun_get_viewdata(int class_) {
 	struct view_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_homun_get_viewdata_pre ) {
 		struct view_data* (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -25986,6 +27005,7 @@ enum homun_type HP_homun_class2type(int class_) {
 	enum homun_type retVal___ = HT_INVALID;
 	if( HPMHooks.count.HP_homun_class2type_pre ) {
 		enum homun_type (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_class2type_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_class2type_pre[hIndex].func;
 			retVal___ = preHookFunc(&class_);
@@ -26011,6 +27031,7 @@ void HP_homun_damaged(struct homun_data *hd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_damaged_pre ) {
 		void (*preHookFunc) (struct homun_data *hd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_damaged_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_damaged_pre[hIndex].func;
 			preHookFunc(hd);
@@ -26037,6 +27058,7 @@ int HP_homun_dead(struct homun_data *hd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_dead_pre ) {
 		int (*preHookFunc) (struct homun_data *hd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_dead_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_dead_pre[hIndex].func;
 			retVal___ = preHookFunc(hd);
@@ -26063,6 +27085,7 @@ int HP_homun_vaporize(struct map_session_data *sd, enum homun_state flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_vaporize_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, enum homun_state *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_vaporize_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_vaporize_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &flag);
@@ -26089,6 +27112,7 @@ int HP_homun_delete(struct homun_data *hd, int emote) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_delete_pre ) {
 		int (*preHookFunc) (struct homun_data *hd, int *emote);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delete_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_delete_pre[hIndex].func;
 			retVal___ = preHookFunc(hd, &emote);
@@ -26115,6 +27139,7 @@ int HP_homun_checkskill(struct homun_data *hd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_checkskill_pre ) {
 		int (*preHookFunc) (struct homun_data *hd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -26141,6 +27166,7 @@ int HP_homun_calc_skilltree(struct homun_data *hd, int flag_evolve) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_calc_skilltree_pre ) {
 		int (*preHookFunc) (struct homun_data *hd, int *flag_evolve);
+		*HPMforce_return = false;
 		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);
@@ -26167,6 +27193,7 @@ int HP_homun_skill_tree_get_max(int id, int b_class) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_skill_tree_get_max_pre ) {
 		int (*preHookFunc) (int *id, int *b_class);
+		*HPMforce_return = false;
 		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);
@@ -26192,6 +27219,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skillup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_skillup_pre[hIndex].func;
 			preHookFunc(hd, &skill_id);
@@ -26218,6 +27246,7 @@ bool HP_homun_levelup(struct homun_data *hd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_levelup_pre ) {
 		bool (*preHookFunc) (struct homun_data *hd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_levelup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_levelup_pre[hIndex].func;
 			retVal___ = preHookFunc(hd);
@@ -26244,6 +27273,7 @@ int HP_homun_change_class(struct homun_data *hd, short class_) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_change_class_pre ) {
 		int (*preHookFunc) (struct homun_data *hd, short *class_);
+		*HPMforce_return = false;
 		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_);
@@ -26270,6 +27300,7 @@ bool HP_homun_evolve(struct homun_data *hd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_evolve_pre ) {
 		bool (*preHookFunc) (struct homun_data *hd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_evolve_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_evolve_pre[hIndex].func;
 			retVal___ = preHookFunc(hd);
@@ -26296,6 +27327,7 @@ bool HP_homun_mutate(struct homun_data *hd, int homun_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_mutate_pre ) {
 		bool (*preHookFunc) (struct homun_data *hd, int *homun_id);
+		*HPMforce_return = false;
 		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);
@@ -26322,6 +27354,7 @@ int HP_homun_gainexp(struct homun_data *hd, unsigned int exp) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_gainexp_pre ) {
 		int (*preHookFunc) (struct homun_data *hd, unsigned int *exp);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_gainexp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_gainexp_pre[hIndex].func;
 			retVal___ = preHookFunc(hd, &exp);
@@ -26348,6 +27381,7 @@ unsigned int HP_homun_add_intimacy(struct homun_data *hd, unsigned int value) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_add_intimacy_pre ) {
 		unsigned int (*preHookFunc) (struct homun_data *hd, unsigned int *value);
+		*HPMforce_return = false;
 		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);
@@ -26374,6 +27408,7 @@ unsigned int HP_homun_consume_intimacy(struct homun_data *hd, unsigned int value
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_consume_intimacy_pre ) {
 		unsigned int (*preHookFunc) (struct homun_data *hd, unsigned int *value);
+		*HPMforce_return = false;
 		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);
@@ -26399,6 +27434,7 @@ void HP_homun_healed(struct homun_data *hd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_healed_pre ) {
 		void (*preHookFunc) (struct homun_data *hd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_healed_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_healed_pre[hIndex].func;
 			preHookFunc(hd);
@@ -26424,6 +27460,7 @@ void HP_homun_save(struct homun_data *hd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_save_pre ) {
 		void (*preHookFunc) (struct homun_data *hd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_save_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_save_pre[hIndex].func;
 			preHookFunc(hd);
@@ -26450,6 +27487,7 @@ unsigned char HP_homun_menu(struct map_session_data *sd, unsigned char menu_num)
 	unsigned char retVal___ = 0;
 	if( HPMHooks.count.HP_homun_menu_pre ) {
 		unsigned char (*preHookFunc) (struct map_session_data *sd, unsigned char *menu_num);
+		*HPMforce_return = false;
 		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);
@@ -26476,6 +27514,7 @@ bool HP_homun_feed(struct map_session_data *sd, struct homun_data *hd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_feed_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, struct homun_data *hd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_feed_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_feed_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, hd);
@@ -26502,6 +27541,7 @@ int HP_homun_hunger_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_hunger_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -26527,6 +27567,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -26553,6 +27594,7 @@ int HP_homun_change_name(struct map_session_data *sd, char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_change_name_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, char *name);
+		*HPMforce_return = false;
 		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);
@@ -26579,6 +27621,7 @@ bool HP_homun_change_name_ack(struct map_session_data *sd, char *name, int flag)
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_change_name_ack_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, char *name, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -26605,6 +27648,7 @@ int HP_homun_db_search(int key, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_homun_db_search_pre ) {
 		int (*preHookFunc) (int *key, int *type);
+		*HPMforce_return = false;
 		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);
@@ -26631,6 +27675,7 @@ bool HP_homun_create(struct map_session_data *sd, struct s_homunculus *hom) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_create_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, struct s_homunculus *hom);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_create_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_create_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, hom);
@@ -26656,6 +27701,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_timers_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_init_timers_pre[hIndex].func;
 			preHookFunc(hd);
@@ -26682,6 +27728,7 @@ bool HP_homun_call(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_call_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_call_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_call_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -26708,6 +27755,7 @@ bool HP_homun_recv_data(int account_id, struct s_homunculus *sh, int flag) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_recv_data_pre ) {
 		bool (*preHookFunc) (int *account_id, struct s_homunculus *sh, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -26734,6 +27782,7 @@ bool HP_homun_creation_request(struct map_session_data *sd, int class_) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_creation_request_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -26760,6 +27809,7 @@ bool HP_homun_ressurect(struct map_session_data *sd, unsigned char per, short x,
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_ressurect_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, unsigned char *per, short *x, short *y);
+		*HPMforce_return = false;
 		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);
@@ -26785,6 +27835,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_revive_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_revive_pre[hIndex].func;
 			preHookFunc(hd, &hp, &sp);
@@ -26810,6 +27861,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_stat_reset_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_stat_reset_pre[hIndex].func;
 			preHookFunc(hd);
@@ -26836,6 +27888,7 @@ bool HP_homun_shuffle(struct homun_data *hd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_shuffle_pre ) {
 		bool (*preHookFunc) (struct homun_data *hd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_shuffle_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_shuffle_pre[hIndex].func;
 			retVal___ = preHookFunc(hd);
@@ -26862,6 +27915,7 @@ bool HP_homun_read_db_sub(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_read_db_sub_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -26887,6 +27941,7 @@ void HP_homun_read_db(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_read_db_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_read_db_pre[hIndex].func;
 			preHookFunc();
@@ -26913,6 +27968,7 @@ bool HP_homun_read_skill_db_sub(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_homun_read_skill_db_sub_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -26938,6 +27994,7 @@ void HP_homun_skill_db_read(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_skill_db_read_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -26963,6 +28020,7 @@ void HP_homun_exp_db_read(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_homun_exp_db_read_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -26988,6 +28046,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_addspiritball_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_addspiritball_pre[hIndex].func;
 			preHookFunc(hd, &max);
@@ -27013,6 +28072,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delspiritball_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_homun_delspiritball_pre[hIndex].func;
 			preHookFunc(hd, &count, &type);
@@ -27039,6 +28099,7 @@ void HP_instance_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_instance_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -27064,6 +28125,7 @@ void HP_instance_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_instance_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_final_pre[hIndex].func;
 			preHookFunc();
@@ -27089,6 +28151,7 @@ void HP_instance_reload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_instance_reload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_reload_pre[hIndex].func;
 			preHookFunc();
@@ -27115,6 +28178,7 @@ int HP_instance_create(int party_id, const char *name, enum instance_owner_type
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_instance_create_pre ) {
 		int (*preHookFunc) (int *party_id, const char *name, enum instance_owner_type *type);
+		*HPMforce_return = false;
 		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);
@@ -27141,6 +28205,7 @@ int HP_instance_add_map(const char *name, int instance_id, bool usebasename, con
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_instance_add_map_pre ) {
 		int (*preHookFunc) (const char *name, int *instance_id, bool *usebasename, const char *map_name);
+		*HPMforce_return = false;
 		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);
@@ -27166,6 +28231,7 @@ void HP_instance_del_map(int16 m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_instance_del_map_pre ) {
 		void (*preHookFunc) (int16 *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_del_map_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_del_map_pre[hIndex].func;
 			preHookFunc(&m);
@@ -27192,6 +28258,7 @@ int HP_instance_map2imap(int16 m, int instance_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_instance_map2imap_pre ) {
 		int (*preHookFunc) (int16 *m, int *instance_id);
+		*HPMforce_return = false;
 		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);
@@ -27218,6 +28285,7 @@ int HP_instance_mapid2imapid(int16 m, int instance_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_instance_mapid2imapid_pre ) {
 		int (*preHookFunc) (int16 *m, int *instance_id);
+		*HPMforce_return = false;
 		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);
@@ -27244,6 +28312,7 @@ int HP_instance_mapname2imap(const char *map_name, int instance_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_instance_mapname2imap_pre ) {
 		int (*preHookFunc) (const char *map_name, int *instance_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_mapname2imap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_mapname2imap_pre[hIndex].func;
 			retVal___ = preHookFunc(map_name, &instance_id);
@@ -27270,6 +28339,7 @@ int HP_instance_map_npcsub(struct block_list *bl, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_instance_map_npcsub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list args);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_map_npcsub_pre; hIndex++ ) {
 			va_list args___copy; va_copy(args___copy, args);
 			preHookFunc = HPMHooks.list.HP_instance_map_npcsub_pre[hIndex].func;
@@ -27302,6 +28372,7 @@ int HP_instance_init_npc(struct block_list *bl, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_instance_init_npc_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list args);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_npc_pre; hIndex++ ) {
 			va_list args___copy; va_copy(args___copy, args);
 			preHookFunc = HPMHooks.list.HP_instance_init_npc_pre[hIndex].func;
@@ -27333,6 +28404,7 @@ void HP_instance_destroy(int instance_id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_instance_destroy_pre ) {
 		void (*preHookFunc) (int *instance_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_destroy_pre[hIndex].func;
 			preHookFunc(&instance_id);
@@ -27358,6 +28430,7 @@ void HP_instance_start(int instance_id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_instance_start_pre ) {
 		void (*preHookFunc) (int *instance_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_start_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_start_pre[hIndex].func;
 			preHookFunc(&instance_id);
@@ -27383,6 +28456,7 @@ void HP_instance_check_idle(int instance_id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_instance_check_idle_pre ) {
 		void (*preHookFunc) (int *instance_id);
+		*HPMforce_return = false;
 		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);
@@ -27408,6 +28482,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_kick_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_check_kick_pre[hIndex].func;
 			preHookFunc(sd);
@@ -27433,6 +28508,7 @@ void HP_instance_set_timeout(int instance_id, unsigned int progress_timeout, uns
 	int hIndex = 0;
 	if( HPMHooks.count.HP_instance_set_timeout_pre ) {
 		void (*preHookFunc) (int *instance_id, unsigned int *progress_timeout, unsigned int *idle_timeout);
+		*HPMforce_return = false;
 		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);
@@ -27459,6 +28535,7 @@ bool HP_instance_valid(int instance_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_instance_valid_pre ) {
 		bool (*preHookFunc) (int *instance_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_valid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_instance_valid_pre[hIndex].func;
 			retVal___ = preHookFunc(&instance_id);
@@ -27485,6 +28562,7 @@ int HP_instance_destroy_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_instance_destroy_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -27512,6 +28590,7 @@ int HP_intif_parse(int fd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_parse_pre ) {
 		int (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_parse_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_parse_pre[hIndex].func;
 			retVal___ = preHookFunc(&fd);
@@ -27538,6 +28617,7 @@ int HP_intif_create_pet(int account_id, int char_id, short pet_type, short pet_l
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -27564,6 +28644,7 @@ int HP_intif_broadcast(const char *mes, size_t len, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_broadcast_pre ) {
 		int (*preHookFunc) (const char *mes, size_t *len, int *type);
+		*HPMforce_return = false;
 		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);
@@ -27590,6 +28671,7 @@ int HP_intif_broadcast2(const char *mes, size_t len, unsigned int fontColor, sho
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_broadcast2_pre ) {
 		int (*preHookFunc) (const char *mes, size_t *len, unsigned int *fontColor, short *fontType, short *fontSize, short *fontAlign, short *fontY);
+		*HPMforce_return = false;
 		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);
@@ -27616,6 +28698,7 @@ int HP_intif_main_message(struct map_session_data *sd, const char *message) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_main_message_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, const char *message);
+		*HPMforce_return = false;
 		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);
@@ -27642,6 +28725,7 @@ int HP_intif_wis_message(struct map_session_data *sd, char *nick, char *mes, siz
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_wis_message_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, char *nick, char *mes, size_t *mes_len);
+		*HPMforce_return = false;
 		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);
@@ -27668,6 +28752,7 @@ int HP_intif_wis_message_to_gm(char *Wisp_name, int permission, char *mes) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_wis_message_to_gm_pre ) {
 		int (*preHookFunc) (char *Wisp_name, int *permission, char *mes);
+		*HPMforce_return = false;
 		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);
@@ -27694,6 +28779,7 @@ int HP_intif_saveregistry(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_saveregistry_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_saveregistry_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_saveregistry_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -27720,6 +28806,7 @@ int HP_intif_request_registry(struct map_session_data *sd, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_request_registry_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -27746,6 +28833,7 @@ int HP_intif_request_guild_storage(int account_id, int guild_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_request_guild_storage_pre ) {
 		int (*preHookFunc) (int *account_id, int *guild_id);
+		*HPMforce_return = false;
 		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);
@@ -27772,6 +28860,7 @@ int HP_intif_send_guild_storage(int account_id, struct guild_storage *gstor) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_send_guild_storage_pre ) {
 		int (*preHookFunc) (int *account_id, struct guild_storage *gstor);
+		*HPMforce_return = false;
 		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);
@@ -27798,6 +28887,7 @@ int HP_intif_create_party(struct party_member *member, char *name, int item, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_create_party_pre ) {
 		int (*preHookFunc) (struct party_member *member, char *name, int *item, int *item2);
+		*HPMforce_return = false;
 		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);
@@ -27824,6 +28914,7 @@ int HP_intif_request_partyinfo(int party_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_request_partyinfo_pre ) {
 		int (*preHookFunc) (int *party_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -27850,6 +28941,7 @@ int HP_intif_party_addmember(int party_id, struct party_member *member) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_party_addmember_pre ) {
 		int (*preHookFunc) (int *party_id, struct party_member *member);
+		*HPMforce_return = false;
 		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);
@@ -27876,6 +28968,7 @@ int HP_intif_party_changeoption(int party_id, int account_id, int exp, int item)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_party_changeoption_pre ) {
 		int (*preHookFunc) (int *party_id, int *account_id, int *exp, int *item);
+		*HPMforce_return = false;
 		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);
@@ -27902,6 +28995,7 @@ int HP_intif_party_leave(int party_id, int account_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_party_leave_pre ) {
 		int (*preHookFunc) (int *party_id, int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -27928,6 +29022,7 @@ int HP_intif_party_changemap(struct map_session_data *sd, int online) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_party_changemap_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *online);
+		*HPMforce_return = false;
 		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);
@@ -27954,6 +29049,7 @@ int HP_intif_break_party(int party_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_break_party_pre ) {
 		int (*preHookFunc) (int *party_id);
+		*HPMforce_return = false;
 		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);
@@ -27980,6 +29076,7 @@ int HP_intif_party_message(int party_id, int account_id, const char *mes, int le
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_party_message_pre ) {
 		int (*preHookFunc) (int *party_id, int *account_id, const char *mes, int *len);
+		*HPMforce_return = false;
 		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);
@@ -28006,6 +29103,7 @@ int HP_intif_party_leaderchange(int party_id, int account_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_party_leaderchange_pre ) {
 		int (*preHookFunc) (int *party_id, int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -28032,6 +29130,7 @@ int HP_intif_guild_create(const char *name, const struct guild_member *master) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_create_pre ) {
 		int (*preHookFunc) (const char *name, const struct guild_member *master);
+		*HPMforce_return = false;
 		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);
@@ -28058,6 +29157,7 @@ int HP_intif_guild_request_info(int guild_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_request_info_pre ) {
 		int (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		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);
@@ -28084,6 +29184,7 @@ int HP_intif_guild_addmember(int guild_id, struct guild_member *m) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_addmember_pre ) {
 		int (*preHookFunc) (int *guild_id, struct guild_member *m);
+		*HPMforce_return = false;
 		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);
@@ -28110,6 +29211,7 @@ int HP_intif_guild_leave(int guild_id, int account_id, int char_id, int flag, co
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_leave_pre ) {
 		int (*preHookFunc) (int *guild_id, int *account_id, int *char_id, int *flag, const char *mes);
+		*HPMforce_return = false;
 		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);
@@ -28136,6 +29238,7 @@ int HP_intif_guild_memberinfoshort(int guild_id, int account_id, int char_id, in
 	int retVal___ = 0;
 	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_);
+		*HPMforce_return = false;
 		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_);
@@ -28162,6 +29265,7 @@ int HP_intif_guild_break(int guild_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_break_pre ) {
 		int (*preHookFunc) (int *guild_id);
+		*HPMforce_return = false;
 		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);
@@ -28188,6 +29292,7 @@ int HP_intif_guild_message(int guild_id, int account_id, const char *mes, int le
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_message_pre ) {
 		int (*preHookFunc) (int *guild_id, int *account_id, const char *mes, int *len);
+		*HPMforce_return = false;
 		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);
@@ -28214,6 +29319,7 @@ int HP_intif_guild_change_gm(int guild_id, const char *name, size_t len) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_change_gm_pre ) {
 		int (*preHookFunc) (int *guild_id, const char *name, size_t *len);
+		*HPMforce_return = false;
 		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);
@@ -28240,6 +29346,7 @@ int HP_intif_guild_change_basicinfo(int guild_id, int type, const void *data, in
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_change_basicinfo_pre ) {
 		int (*preHookFunc) (int *guild_id, int *type, const void *data, int *len);
+		*HPMforce_return = false;
 		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);
@@ -28266,6 +29373,7 @@ int HP_intif_guild_change_memberinfo(int guild_id, int account_id, int char_id,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -28292,6 +29400,7 @@ int HP_intif_guild_position(int guild_id, int idx, struct guild_position *p) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_position_pre ) {
 		int (*preHookFunc) (int *guild_id, int *idx, struct guild_position *p);
+		*HPMforce_return = false;
 		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);
@@ -28318,6 +29427,7 @@ int HP_intif_guild_skillup(int guild_id, uint16 skill_id, int account_id, int ma
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_skillup_pre ) {
 		int (*preHookFunc) (int *guild_id, uint16 *skill_id, int *account_id, int *max);
+		*HPMforce_return = false;
 		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);
@@ -28344,6 +29454,7 @@ int HP_intif_guild_alliance(int guild_id1, int guild_id2, int account_id1, int a
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_alliance_pre ) {
 		int (*preHookFunc) (int *guild_id1, int *guild_id2, int *account_id1, int *account_id2, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -28370,6 +29481,7 @@ int HP_intif_guild_notice(int guild_id, const char *mes1, const char *mes2) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_notice_pre ) {
 		int (*preHookFunc) (int *guild_id, const char *mes1, const char *mes2);
+		*HPMforce_return = false;
 		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);
@@ -28396,6 +29508,7 @@ int HP_intif_guild_emblem(int guild_id, int len, const char *data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_emblem_pre ) {
 		int (*preHookFunc) (int *guild_id, int *len, const char *data);
+		*HPMforce_return = false;
 		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);
@@ -28422,6 +29535,7 @@ int HP_intif_guild_castle_dataload(int num, int *castle_ids) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_castle_dataload_pre ) {
 		int (*preHookFunc) (int *num, int *castle_ids);
+		*HPMforce_return = false;
 		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);
@@ -28448,6 +29562,7 @@ int HP_intif_guild_castle_datasave(int castle_id, int index, int value) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_guild_castle_datasave_pre ) {
 		int (*preHookFunc) (int *castle_id, int *index, int *value);
+		*HPMforce_return = false;
 		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);
@@ -28473,6 +29588,7 @@ void HP_intif_itembound_req(int char_id, int aid, int guild_id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_itembound_req_pre ) {
 		void (*preHookFunc) (int *char_id, int *aid, int *guild_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_itembound_req_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_itembound_req_pre[hIndex].func;
 			preHookFunc(&char_id, &aid, &guild_id);
@@ -28499,6 +29615,7 @@ int HP_intif_request_petdata(int account_id, int char_id, int pet_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_request_petdata_pre ) {
 		int (*preHookFunc) (int *account_id, int *char_id, int *pet_id);
+		*HPMforce_return = false;
 		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);
@@ -28525,6 +29642,7 @@ int HP_intif_save_petdata(int account_id, struct s_pet *p) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_save_petdata_pre ) {
 		int (*preHookFunc) (int *account_id, struct s_pet *p);
+		*HPMforce_return = false;
 		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);
@@ -28551,6 +29669,7 @@ int HP_intif_delete_petdata(int pet_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_delete_petdata_pre ) {
 		int (*preHookFunc) (int *pet_id);
+		*HPMforce_return = false;
 		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);
@@ -28577,6 +29696,7 @@ int HP_intif_rename(struct map_session_data *sd, int type, char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_rename_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, char *name);
+		*HPMforce_return = false;
 		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);
@@ -28603,6 +29723,7 @@ int HP_intif_homunculus_create(int account_id, struct s_homunculus *sh) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_homunculus_create_pre ) {
 		int (*preHookFunc) (int *account_id, struct s_homunculus *sh);
+		*HPMforce_return = false;
 		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);
@@ -28629,6 +29750,7 @@ bool HP_intif_homunculus_requestload(int account_id, int homun_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_intif_homunculus_requestload_pre ) {
 		bool (*preHookFunc) (int *account_id, int *homun_id);
+		*HPMforce_return = false;
 		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);
@@ -28655,6 +29777,7 @@ int HP_intif_homunculus_requestsave(int account_id, struct s_homunculus *sh) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_homunculus_requestsave_pre ) {
 		int (*preHookFunc) (int *account_id, struct s_homunculus *sh);
+		*HPMforce_return = false;
 		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);
@@ -28681,6 +29804,7 @@ int HP_intif_homunculus_requestdelete(int homun_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_homunculus_requestdelete_pre ) {
 		int (*preHookFunc) (int *homun_id);
+		*HPMforce_return = false;
 		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);
@@ -28706,6 +29830,7 @@ void HP_intif_request_questlog(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_request_questlog_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_questlog_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_request_questlog_pre[hIndex].func;
 			preHookFunc(sd);
@@ -28732,6 +29857,7 @@ int HP_intif_quest_save(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_quest_save_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -28758,6 +29884,7 @@ int HP_intif_mercenary_create(struct s_mercenary *merc) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_mercenary_create_pre ) {
 		int (*preHookFunc) (struct s_mercenary *merc);
+		*HPMforce_return = false;
 		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);
@@ -28784,6 +29911,7 @@ int HP_intif_mercenary_request(int merc_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_mercenary_request_pre ) {
 		int (*preHookFunc) (int *merc_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -28810,6 +29938,7 @@ int HP_intif_mercenary_delete(int merc_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_mercenary_delete_pre ) {
 		int (*preHookFunc) (int *merc_id);
+		*HPMforce_return = false;
 		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);
@@ -28836,6 +29965,7 @@ int HP_intif_mercenary_save(struct s_mercenary *merc) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_mercenary_save_pre ) {
 		int (*preHookFunc) (struct s_mercenary *merc);
+		*HPMforce_return = false;
 		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);
@@ -28862,6 +29992,7 @@ int HP_intif_Mail_requestinbox(int char_id, unsigned char flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Mail_requestinbox_pre ) {
 		int (*preHookFunc) (int *char_id, unsigned char *flag);
+		*HPMforce_return = false;
 		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);
@@ -28888,6 +30019,7 @@ int HP_intif_Mail_read(int mail_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Mail_read_pre ) {
 		int (*preHookFunc) (int *mail_id);
+		*HPMforce_return = false;
 		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);
@@ -28914,6 +30046,7 @@ int HP_intif_Mail_getattach(int char_id, int mail_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Mail_getattach_pre ) {
 		int (*preHookFunc) (int *char_id, int *mail_id);
+		*HPMforce_return = false;
 		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);
@@ -28940,6 +30073,7 @@ int HP_intif_Mail_delete(int char_id, int mail_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Mail_delete_pre ) {
 		int (*preHookFunc) (int *char_id, int *mail_id);
+		*HPMforce_return = false;
 		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);
@@ -28966,6 +30100,7 @@ int HP_intif_Mail_return(int char_id, int mail_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Mail_return_pre ) {
 		int (*preHookFunc) (int *char_id, int *mail_id);
+		*HPMforce_return = false;
 		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);
@@ -28992,6 +30127,7 @@ int HP_intif_Mail_send(int account_id, struct mail_message *msg) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Mail_send_pre ) {
 		int (*preHookFunc) (int *account_id, struct mail_message *msg);
+		*HPMforce_return = false;
 		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);
@@ -29018,6 +30154,7 @@ int HP_intif_Auction_requestlist(int char_id, short type, int price, const char
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Auction_requestlist_pre ) {
 		int (*preHookFunc) (int *char_id, short *type, int *price, const char *searchtext, short *page);
+		*HPMforce_return = false;
 		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);
@@ -29044,6 +30181,7 @@ int HP_intif_Auction_register(struct auction_data *auction) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Auction_register_pre ) {
 		int (*preHookFunc) (struct auction_data *auction);
+		*HPMforce_return = false;
 		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);
@@ -29070,6 +30208,7 @@ int HP_intif_Auction_cancel(int char_id, unsigned int auction_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Auction_cancel_pre ) {
 		int (*preHookFunc) (int *char_id, unsigned int *auction_id);
+		*HPMforce_return = false;
 		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);
@@ -29096,6 +30235,7 @@ int HP_intif_Auction_close(int char_id, unsigned int auction_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Auction_close_pre ) {
 		int (*preHookFunc) (int *char_id, unsigned int *auction_id);
+		*HPMforce_return = false;
 		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);
@@ -29122,6 +30262,7 @@ int HP_intif_Auction_bid(int char_id, const char *name, unsigned int auction_id,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_Auction_bid_pre ) {
 		int (*preHookFunc) (int *char_id, const char *name, unsigned int *auction_id, int *bid);
+		*HPMforce_return = false;
 		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);
@@ -29148,6 +30289,7 @@ int HP_intif_elemental_create(struct s_elemental *ele) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_elemental_create_pre ) {
 		int (*preHookFunc) (struct s_elemental *ele);
+		*HPMforce_return = false;
 		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);
@@ -29174,6 +30316,7 @@ int HP_intif_elemental_request(int ele_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_elemental_request_pre ) {
 		int (*preHookFunc) (int *ele_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -29200,6 +30343,7 @@ int HP_intif_elemental_delete(int ele_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_elemental_delete_pre ) {
 		int (*preHookFunc) (int *ele_id);
+		*HPMforce_return = false;
 		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);
@@ -29226,6 +30370,7 @@ int HP_intif_elemental_save(struct s_elemental *ele) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_elemental_save_pre ) {
 		int (*preHookFunc) (struct s_elemental *ele);
+		*HPMforce_return = false;
 		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);
@@ -29251,6 +30396,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -29277,6 +30423,7 @@ int HP_intif_CheckForCharServer(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_CheckForCharServer_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_CheckForCharServer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_CheckForCharServer_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -29302,6 +30449,7 @@ void HP_intif_pWisMessage(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pWisMessage_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pWisMessage_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29327,6 +30475,7 @@ void HP_intif_pWisEnd(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pWisEnd_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisEnd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pWisEnd_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29353,6 +30502,7 @@ int HP_intif_pWisToGM_sub(struct map_session_data *sd, va_list va) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_intif_pWisToGM_sub_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list va);
+		*HPMforce_return = false;
 		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;
@@ -29384,6 +30534,7 @@ void HP_intif_pWisToGM(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pWisToGM_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pWisToGM_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29409,6 +30560,7 @@ void HP_intif_pRegisters(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pRegisters_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRegisters_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pRegisters_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29434,6 +30586,7 @@ void HP_intif_pChangeNameOk(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pChangeNameOk_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pChangeNameOk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pChangeNameOk_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29459,6 +30612,7 @@ void HP_intif_pMessageToFD(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMessageToFD_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMessageToFD_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMessageToFD_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29484,6 +30638,7 @@ void HP_intif_pLoadGuildStorage(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pLoadGuildStorage_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pLoadGuildStorage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pLoadGuildStorage_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29509,6 +30664,7 @@ void HP_intif_pSaveGuildStorage(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pSaveGuildStorage_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveGuildStorage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pSaveGuildStorage_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29534,6 +30690,7 @@ void HP_intif_pPartyCreated(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pPartyCreated_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyCreated_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pPartyCreated_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29559,6 +30716,7 @@ void HP_intif_pPartyInfo(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pPartyInfo_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pPartyInfo_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29584,6 +30742,7 @@ void HP_intif_pPartyMemberAdded(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pPartyMemberAdded_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberAdded_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pPartyMemberAdded_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29609,6 +30768,7 @@ void HP_intif_pPartyOptionChanged(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pPartyOptionChanged_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyOptionChanged_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pPartyOptionChanged_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29634,6 +30794,7 @@ void HP_intif_pPartyMemberWithdraw(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pPartyMemberWithdraw_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberWithdraw_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pPartyMemberWithdraw_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29659,6 +30820,7 @@ void HP_intif_pPartyMove(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pPartyMove_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMove_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pPartyMove_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29684,6 +30846,7 @@ void HP_intif_pPartyBroken(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pPartyBroken_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyBroken_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pPartyBroken_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29709,6 +30872,7 @@ void HP_intif_pPartyMessage(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pPartyMessage_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pPartyMessage_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29734,6 +30898,7 @@ void HP_intif_pGuildCreated(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildCreated_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCreated_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildCreated_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29759,6 +30924,7 @@ void HP_intif_pGuildInfo(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildInfo_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildInfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildInfo_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29784,6 +30950,7 @@ void HP_intif_pGuildMemberAdded(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildMemberAdded_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberAdded_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildMemberAdded_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29809,6 +30976,7 @@ void HP_intif_pGuildMemberWithdraw(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildMemberWithdraw_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberWithdraw_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildMemberWithdraw_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29834,6 +31002,7 @@ void HP_intif_pGuildMemberInfoShort(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildMemberInfoShort_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoShort_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoShort_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29859,6 +31028,7 @@ void HP_intif_pGuildBroken(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildBroken_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBroken_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildBroken_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29884,6 +31054,7 @@ void HP_intif_pGuildMessage(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildMessage_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildMessage_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29909,6 +31080,7 @@ void HP_intif_pGuildBasicInfoChanged(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildBasicInfoChanged_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBasicInfoChanged_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildBasicInfoChanged_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29934,6 +31106,7 @@ void HP_intif_pGuildMemberInfoChanged(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildMemberInfoChanged_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoChanged_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoChanged_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29959,6 +31132,7 @@ void HP_intif_pGuildPosition(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildPosition_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildPosition_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildPosition_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -29984,6 +31158,7 @@ void HP_intif_pGuildSkillUp(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildSkillUp_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildSkillUp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildSkillUp_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30009,6 +31184,7 @@ void HP_intif_pGuildAlliance(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildAlliance_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildAlliance_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildAlliance_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30034,6 +31210,7 @@ void HP_intif_pGuildNotice(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildNotice_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildNotice_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildNotice_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30059,6 +31236,7 @@ void HP_intif_pGuildEmblem(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildEmblem_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildEmblem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildEmblem_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30084,6 +31262,7 @@ void HP_intif_pGuildCastleDataLoad(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildCastleDataLoad_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCastleDataLoad_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildCastleDataLoad_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30109,6 +31288,7 @@ void HP_intif_pGuildMasterChanged(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pGuildMasterChanged_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMasterChanged_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pGuildMasterChanged_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30134,6 +31314,7 @@ void HP_intif_pQuestLog(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pQuestLog_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestLog_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pQuestLog_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30159,6 +31340,7 @@ void HP_intif_pQuestSave(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pQuestSave_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestSave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pQuestSave_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30184,6 +31366,7 @@ void HP_intif_pMailInboxReceived(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMailInboxReceived_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailInboxReceived_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMailInboxReceived_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30209,6 +31392,7 @@ void HP_intif_pMailNew(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMailNew_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailNew_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMailNew_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30234,6 +31418,7 @@ void HP_intif_pMailGetAttach(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMailGetAttach_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailGetAttach_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMailGetAttach_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30259,6 +31444,7 @@ void HP_intif_pMailDelete(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMailDelete_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailDelete_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMailDelete_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30284,6 +31470,7 @@ void HP_intif_pMailReturn(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMailReturn_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailReturn_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMailReturn_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30309,6 +31496,7 @@ void HP_intif_pMailSend(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMailSend_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailSend_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMailSend_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30334,6 +31522,7 @@ void HP_intif_pAuctionResults(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pAuctionResults_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionResults_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pAuctionResults_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30359,6 +31548,7 @@ void HP_intif_pAuctionRegister(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pAuctionRegister_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionRegister_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pAuctionRegister_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30384,6 +31574,7 @@ void HP_intif_pAuctionCancel(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pAuctionCancel_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionCancel_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pAuctionCancel_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30409,6 +31600,7 @@ void HP_intif_pAuctionClose(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pAuctionClose_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionClose_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pAuctionClose_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30434,6 +31626,7 @@ void HP_intif_pAuctionMessage(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pAuctionMessage_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionMessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pAuctionMessage_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30459,6 +31652,7 @@ void HP_intif_pAuctionBid(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pAuctionBid_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionBid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pAuctionBid_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30484,6 +31678,7 @@ void HP_intif_pItembound_ack(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pItembound_ack_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pItembound_ack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pItembound_ack_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30509,6 +31704,7 @@ void HP_intif_pMercenaryReceived(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMercenaryReceived_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryReceived_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMercenaryReceived_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30534,6 +31730,7 @@ void HP_intif_pMercenaryDeleted(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMercenaryDeleted_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryDeleted_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMercenaryDeleted_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30559,6 +31756,7 @@ void HP_intif_pMercenarySaved(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pMercenarySaved_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenarySaved_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pMercenarySaved_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30584,6 +31782,7 @@ void HP_intif_pElementalReceived(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pElementalReceived_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalReceived_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pElementalReceived_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30609,6 +31808,7 @@ void HP_intif_pElementalDeleted(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pElementalDeleted_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalDeleted_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pElementalDeleted_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30634,6 +31834,7 @@ void HP_intif_pElementalSaved(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pElementalSaved_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalSaved_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pElementalSaved_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30659,6 +31860,7 @@ void HP_intif_pCreatePet(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pCreatePet_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreatePet_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pCreatePet_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30684,6 +31886,7 @@ void HP_intif_pRecvPetData(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pRecvPetData_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvPetData_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pRecvPetData_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30709,6 +31912,7 @@ void HP_intif_pSavePetOk(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pSavePetOk_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSavePetOk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pSavePetOk_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30734,6 +31938,7 @@ void HP_intif_pDeletePetOk(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pDeletePetOk_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeletePetOk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pDeletePetOk_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30759,6 +31964,7 @@ void HP_intif_pCreateHomunculus(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pCreateHomunculus_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreateHomunculus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pCreateHomunculus_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30784,6 +31990,7 @@ void HP_intif_pRecvHomunculusData(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pRecvHomunculusData_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvHomunculusData_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pRecvHomunculusData_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30809,6 +32016,7 @@ void HP_intif_pSaveHomunculusOk(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pSaveHomunculusOk_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveHomunculusOk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pSaveHomunculusOk_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30834,6 +32042,7 @@ void HP_intif_pDeleteHomunculusOk(int fd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_intif_pDeleteHomunculusOk_pre ) {
 		void (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeleteHomunculusOk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_intif_pDeleteHomunculusOk_pre[hIndex].func;
 			preHookFunc(&fd);
@@ -30860,6 +32069,7 @@ void HP_ircbot_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_ircbot_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_ircbot_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -30885,6 +32095,7 @@ void HP_ircbot_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_ircbot_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_ircbot_final_pre[hIndex].func;
 			preHookFunc();
@@ -30911,6 +32122,7 @@ int HP_ircbot_parse(int fd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_ircbot_parse_pre ) {
 		int (*preHookFunc) (int *fd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_ircbot_parse_pre[hIndex].func;
 			retVal___ = preHookFunc(&fd);
@@ -30936,6 +32148,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -30961,6 +32174,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -30987,6 +32201,7 @@ struct irc_func* HP_ircbot_func_search(char *function_name) {
 	struct irc_func* retVal___ = NULL;
 	if( HPMHooks.count.HP_ircbot_func_search_pre ) {
 		struct irc_func* (*preHookFunc) (char *function_name);
+		*HPMforce_return = false;
 		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);
@@ -31013,6 +32228,7 @@ int HP_ircbot_connect_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_ircbot_connect_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -31039,6 +32255,7 @@ int HP_ircbot_identify_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_ircbot_identify_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -31065,6 +32282,7 @@ int HP_ircbot_join_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_ircbot_join_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -31090,6 +32308,7 @@ void HP_ircbot_send(char *str) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_ircbot_send_pre ) {
 		void (*preHookFunc) (char *str);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_send_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_ircbot_send_pre[hIndex].func;
 			preHookFunc(str);
@@ -31115,6 +32334,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_relay_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_ircbot_relay_pre[hIndex].func;
 			preHookFunc(name, msg);
@@ -31140,6 +32360,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -31165,6 +32386,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -31190,6 +32412,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -31215,6 +32438,7 @@ void HP_ircbot_userleave(int fd, char *cmd, char *source, char *target, char *ms
 	int hIndex = 0;
 	if( HPMHooks.count.HP_ircbot_userleave_pre ) {
 		void (*preHookFunc) (int *fd, char *cmd, char *source, char *target, char *msg);
+		*HPMforce_return = false;
 		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);
@@ -31240,6 +32464,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -31266,6 +32491,7 @@ void HP_itemdb_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -31291,6 +32517,7 @@ void HP_itemdb_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_final_pre[hIndex].func;
 			preHookFunc();
@@ -31316,6 +32543,7 @@ void HP_itemdb_reload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_reload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_reload_pre[hIndex].func;
 			preHookFunc();
@@ -31341,6 +32569,7 @@ void HP_itemdb_name_constants(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_name_constants_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name_constants_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_name_constants_pre[hIndex].func;
 			preHookFunc();
@@ -31366,6 +32595,7 @@ void HP_itemdb_read_groups(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_read_groups_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_groups_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_read_groups_pre[hIndex].func;
 			preHookFunc();
@@ -31391,6 +32621,7 @@ void HP_itemdb_read_chains(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_read_chains_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_chains_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_read_chains_pre[hIndex].func;
 			preHookFunc();
@@ -31416,6 +32647,7 @@ void HP_itemdb_read_packages(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_read_packages_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_packages_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_read_packages_pre[hIndex].func;
 			preHookFunc();
@@ -31441,6 +32673,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -31467,6 +32700,7 @@ bool HP_itemdb_read_cached_packages(const char *config_filename) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_itemdb_read_cached_packages_pre ) {
 		bool (*preHookFunc) (const char *config_filename);
+		*HPMforce_return = false;
 		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);
@@ -31493,6 +32727,7 @@ struct item_data* HP_itemdb_name2id(const char *str) {
 	struct item_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_itemdb_name2id_pre ) {
 		struct item_data* (*preHookFunc) (const char *str);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name2id_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_name2id_pre[hIndex].func;
 			retVal___ = preHookFunc(str);
@@ -31519,6 +32754,7 @@ struct item_data* HP_itemdb_search_name(const char *name) {
 	struct item_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_itemdb_search_name_pre ) {
 		struct item_data* (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		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);
@@ -31545,6 +32781,7 @@ int HP_itemdb_search_name_array(struct item_data **data, int size, const char *s
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_search_name_array_pre ) {
 		int (*preHookFunc) (struct item_data **data, int *size, const char *str, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -31571,6 +32808,7 @@ struct item_data* HP_itemdb_load(int nameid) {
 	struct item_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_itemdb_load_pre ) {
 		struct item_data* (*preHookFunc) (int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_load_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_load_pre[hIndex].func;
 			retVal___ = preHookFunc(&nameid);
@@ -31597,6 +32835,7 @@ struct item_data* HP_itemdb_search(int nameid) {
 	struct item_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_itemdb_search_pre ) {
 		struct item_data* (*preHookFunc) (int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_search_pre[hIndex].func;
 			retVal___ = preHookFunc(&nameid);
@@ -31623,6 +32862,7 @@ struct item_data* HP_itemdb_exists(int nameid) {
 	struct item_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_itemdb_exists_pre ) {
 		struct item_data* (*preHookFunc) (int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_exists_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_exists_pre[hIndex].func;
 			retVal___ = preHookFunc(&nameid);
@@ -31649,6 +32889,7 @@ bool HP_itemdb_in_group(struct item_group *group, int nameid) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_itemdb_in_group_pre ) {
 		bool (*preHookFunc) (struct item_group *group, int *nameid);
+		*HPMforce_return = false;
 		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);
@@ -31675,6 +32916,7 @@ int HP_itemdb_group_item(struct item_group *group) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_group_item_pre ) {
 		int (*preHookFunc) (struct item_group *group);
+		*HPMforce_return = false;
 		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);
@@ -31701,6 +32943,7 @@ int HP_itemdb_chain_item(unsigned short chain_id, int *rate) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_chain_item_pre ) {
 		int (*preHookFunc) (unsigned short *chain_id, int *rate);
+		*HPMforce_return = false;
 		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);
@@ -31726,6 +32969,7 @@ void HP_itemdb_package_item(struct map_session_data *sd, struct item_package *pa
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_package_item_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct item_package *package);
+		*HPMforce_return = false;
 		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);
@@ -31752,6 +32996,7 @@ int HP_itemdb_searchname_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_searchname_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -31784,6 +33029,7 @@ int HP_itemdb_searchname_array_sub(DBKey key, DBData data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_searchname_array_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -31816,6 +33062,7 @@ int HP_itemdb_searchrandomid(struct item_group *group) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_searchrandomid_pre ) {
 		int (*preHookFunc) (struct item_group *group);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchrandomid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_searchrandomid_pre[hIndex].func;
 			retVal___ = preHookFunc(group);
@@ -31842,6 +33089,7 @@ const char* HP_itemdb_typename(int type) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_itemdb_typename_pre ) {
 		const char* (*preHookFunc) (int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_typename_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_typename_pre[hIndex].func;
 			retVal___ = preHookFunc(&type);
@@ -31867,6 +33115,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobid2mapid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_jobid2mapid_pre[hIndex].func;
 			preHookFunc(bclass, &jobmask);
@@ -31892,6 +33141,7 @@ void HP_itemdb_create_dummy_data(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_create_dummy_data_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -31918,6 +33168,7 @@ struct item_data* HP_itemdb_create_item_data(int nameid) {
 	struct item_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_itemdb_create_item_data_pre ) {
 		struct item_data* (*preHookFunc) (int *nameid);
+		*HPMforce_return = false;
 		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);
@@ -31944,6 +33195,7 @@ int HP_itemdb_isequip(int nameid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_isequip_pre ) {
 		int (*preHookFunc) (int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_isequip_pre[hIndex].func;
 			retVal___ = preHookFunc(&nameid);
@@ -31970,6 +33222,7 @@ int HP_itemdb_isequip2(struct item_data *data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_isequip2_pre ) {
 		int (*preHookFunc) (struct item_data *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_isequip2_pre[hIndex].func;
 			retVal___ = preHookFunc(data);
@@ -31996,6 +33249,7 @@ int HP_itemdb_isstackable(int nameid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_isstackable_pre ) {
 		int (*preHookFunc) (int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_isstackable_pre[hIndex].func;
 			retVal___ = preHookFunc(&nameid);
@@ -32022,6 +33276,7 @@ int HP_itemdb_isstackable2(struct item_data *data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_isstackable2_pre ) {
 		int (*preHookFunc) (struct item_data *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_isstackable2_pre[hIndex].func;
 			retVal___ = preHookFunc(data);
@@ -32048,6 +33303,7 @@ int HP_itemdb_isdropable_sub(struct item_data *item, int gmlv, int unused) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_isdropable_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		*HPMforce_return = false;
 		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);
@@ -32074,6 +33330,7 @@ int HP_itemdb_cantrade_sub(struct item_data *item, int gmlv, int gmlv2) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_cantrade_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *gmlv2);
+		*HPMforce_return = false;
 		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);
@@ -32100,6 +33357,7 @@ int HP_itemdb_canpartnertrade_sub(struct item_data *item, int gmlv, int gmlv2) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_canpartnertrade_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *gmlv2);
+		*HPMforce_return = false;
 		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);
@@ -32126,6 +33384,7 @@ int HP_itemdb_cansell_sub(struct item_data *item, int gmlv, int unused) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_cansell_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		*HPMforce_return = false;
 		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);
@@ -32152,6 +33411,7 @@ int HP_itemdb_cancartstore_sub(struct item_data *item, int gmlv, int unused) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_cancartstore_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		*HPMforce_return = false;
 		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);
@@ -32178,6 +33438,7 @@ int HP_itemdb_canstore_sub(struct item_data *item, int gmlv, int unused) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_canstore_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		*HPMforce_return = false;
 		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);
@@ -32204,6 +33465,7 @@ int HP_itemdb_canguildstore_sub(struct item_data *item, int gmlv, int unused) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_canguildstore_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		*HPMforce_return = false;
 		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);
@@ -32230,6 +33492,7 @@ int HP_itemdb_canmail_sub(struct item_data *item, int gmlv, int unused) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_canmail_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		*HPMforce_return = false;
 		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);
@@ -32256,6 +33519,7 @@ int HP_itemdb_canauction_sub(struct item_data *item, int gmlv, int unused) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_canauction_sub_pre ) {
 		int (*preHookFunc) (struct item_data *item, int *gmlv, int *unused);
+		*HPMforce_return = false;
 		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);
@@ -32282,6 +33546,7 @@ int HP_itemdb_isrestricted(struct item *item, int gmlv, int gmlv2, int ( *func )
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_isrestricted_pre ) {
 		int (*preHookFunc) (struct item *item, int *gmlv, int *gmlv2, int ( *func ) (struct item_data *, int, int));
+		*HPMforce_return = false;
 		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);
@@ -32308,6 +33573,7 @@ int HP_itemdb_isidentified(int nameid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_isidentified_pre ) {
 		int (*preHookFunc) (int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_isidentified_pre[hIndex].func;
 			retVal___ = preHookFunc(&nameid);
@@ -32334,6 +33600,7 @@ int HP_itemdb_isidentified2(struct item_data *data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_isidentified2_pre ) {
 		int (*preHookFunc) (struct item_data *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_isidentified2_pre[hIndex].func;
 			retVal___ = preHookFunc(data);
@@ -32360,6 +33627,7 @@ bool HP_itemdb_read_itemavail(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_itemdb_read_itemavail_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -32386,6 +33654,7 @@ bool HP_itemdb_read_itemtrade(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_itemdb_read_itemtrade_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -32412,6 +33681,7 @@ bool HP_itemdb_read_itemdelay(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_itemdb_read_itemdelay_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -32438,6 +33708,7 @@ bool HP_itemdb_read_stack(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_itemdb_read_stack_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -32464,6 +33735,7 @@ bool HP_itemdb_read_buyingstore(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_itemdb_read_buyingstore_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -32490,6 +33762,7 @@ bool HP_itemdb_read_nouse(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_itemdb_read_nouse_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -32516,6 +33789,7 @@ int HP_itemdb_combo_split_atoi(char *str, int *val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_combo_split_atoi_pre ) {
 		int (*preHookFunc) (char *str, int *val);
+		*HPMforce_return = false;
 		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);
@@ -32541,6 +33815,7 @@ void HP_itemdb_read_combos(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_read_combos_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_combos_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_read_combos_pre[hIndex].func;
 			preHookFunc();
@@ -32567,6 +33842,7 @@ int HP_itemdb_gendercheck(struct item_data *id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_gendercheck_pre ) {
 		int (*preHookFunc) (struct item_data *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_gendercheck_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_gendercheck_pre[hIndex].func;
 			retVal___ = preHookFunc(id);
@@ -32593,6 +33869,7 @@ int HP_itemdb_validate_entry(struct item_data *entry, int n, const char *source)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_validate_entry_pre ) {
 		int (*preHookFunc) (struct item_data *entry, int *n, const char *source);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_validate_entry_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_validate_entry_pre[hIndex].func;
 			retVal___ = preHookFunc(entry, &n, source);
@@ -32619,6 +33896,7 @@ int HP_itemdb_readdb_sql_sub(Sql *handle, int n, const char *source) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_readdb_sql_sub_pre ) {
 		int (*preHookFunc) (Sql *handle, int *n, const char *source);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_sql_sub_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_readdb_sql_sub_pre[hIndex].func;
 			retVal___ = preHookFunc(handle, &n, source);
@@ -32645,6 +33923,7 @@ int HP_itemdb_readdb_libconfig_sub(config_setting_t *it, int n, const char *sour
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_readdb_libconfig_sub_pre ) {
 		int (*preHookFunc) (config_setting_t *it, int *n, const char *source);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_libconfig_sub_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_readdb_libconfig_sub_pre[hIndex].func;
 			retVal___ = preHookFunc(it, &n, source);
@@ -32671,6 +33950,7 @@ int HP_itemdb_readdb_libconfig(const char *filename) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_readdb_libconfig_pre ) {
 		int (*preHookFunc) (const char *filename);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_libconfig_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_readdb_libconfig_pre[hIndex].func;
 			retVal___ = preHookFunc(filename);
@@ -32697,6 +33977,7 @@ int HP_itemdb_readdb_sql(const char *tablename) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_readdb_sql_pre ) {
 		int (*preHookFunc) (const char *tablename);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_sql_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_readdb_sql_pre[hIndex].func;
 			retVal___ = preHookFunc(tablename);
@@ -32723,6 +34004,7 @@ uint64 HP_itemdb_unique_id(struct map_session_data *sd) {
 	uint64 retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_unique_id_pre ) {
 		uint64 (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_unique_id_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_unique_id_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -32748,6 +34030,7 @@ void HP_itemdb_read(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_read_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_read_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -32773,6 +34056,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -32799,6 +34083,7 @@ int HP_itemdb_final_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_itemdb_final_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -32830,6 +34115,7 @@ void HP_itemdb_clear(bool total) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_itemdb_clear_pre ) {
 		void (*preHookFunc) (bool *total);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_clear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_clear_pre[hIndex].func;
 			preHookFunc(&total);
@@ -32856,6 +34142,7 @@ struct item_combo* HP_itemdb_id2combo(unsigned short id) {
 	struct item_combo* retVal___ = NULL;
 	if( HPMHooks.count.HP_itemdb_id2combo_pre ) {
 		struct item_combo* (*preHookFunc) (unsigned short *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_id2combo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_itemdb_id2combo_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -32882,6 +34169,7 @@ void HP_logs_pick_pc(struct map_session_data *sd, e_log_pick_type type, int amou
 	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);
+		*HPMforce_return = false;
 		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);
@@ -32907,6 +34195,7 @@ void HP_logs_pick_mob(struct mob_data *md, e_log_pick_type type, int amount, str
 	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);
+		*HPMforce_return = false;
 		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);
@@ -32932,6 +34221,7 @@ void HP_logs_zeny(struct map_session_data *sd, e_log_pick_type type, struct map_
 	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);
+		*HPMforce_return = false;
 		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);
@@ -32957,6 +34247,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_npc_pre[hIndex].func;
 			preHookFunc(sd, message);
@@ -32982,6 +34273,7 @@ void HP_logs_chat(e_log_chat_type type, int type_id, int src_charid, int src_acc
 	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);
+		*HPMforce_return = false;
 		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);
@@ -33007,6 +34299,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_atcommand_pre[hIndex].func;
 			preHookFunc(sd, message);
@@ -33032,6 +34325,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_branch_pre[hIndex].func;
 			preHookFunc(sd);
@@ -33057,6 +34351,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -33082,6 +34377,7 @@ void HP_logs_pick_sub(int id, int16 m, e_log_pick_type type, int amount, struct
 	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);
+		*HPMforce_return = false;
 		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);
@@ -33107,6 +34403,7 @@ void HP_logs_zeny_sub(struct map_session_data *sd, e_log_pick_type type, struct
 	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);
+		*HPMforce_return = false;
 		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);
@@ -33132,6 +34429,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -33157,6 +34455,7 @@ void HP_logs_chat_sub(e_log_chat_type type, int type_id, int src_charid, int src
 	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);
+		*HPMforce_return = false;
 		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);
@@ -33182,6 +34481,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -33207,6 +34507,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_sub_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_branch_sub_pre[hIndex].func;
 			preHookFunc(sd);
@@ -33232,6 +34533,7 @@ void HP_logs_mvpdrop_sub(struct map_session_data *sd, int monster_id, int *log_m
 	int hIndex = 0;
 	if( HPMHooks.count.HP_logs_mvpdrop_sub_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *monster_id, int *log_mvp);
+		*HPMforce_return = false;
 		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);
@@ -33258,6 +34560,7 @@ int HP_logs_config_read(const char *cfgName) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_logs_config_read_pre ) {
 		int (*preHookFunc) (const char *cfgName);
+		*HPMforce_return = false;
 		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);
@@ -33283,6 +34586,7 @@ void HP_logs_config_done(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_logs_config_done_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_config_done_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_config_done_pre[hIndex].func;
 			preHookFunc();
@@ -33308,6 +34612,7 @@ void HP_logs_sql_init(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_logs_sql_init_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_sql_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_sql_init_pre[hIndex].func;
 			preHookFunc();
@@ -33333,6 +34638,7 @@ void HP_logs_sql_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_logs_sql_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_sql_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_sql_final_pre[hIndex].func;
 			preHookFunc();
@@ -33359,6 +34665,7 @@ char HP_logs_picktype2char(e_log_pick_type type) {
 	char retVal___ = 0;
 	if( HPMHooks.count.HP_logs_picktype2char_pre ) {
 		char (*preHookFunc) (e_log_pick_type *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_picktype2char_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_picktype2char_pre[hIndex].func;
 			retVal___ = preHookFunc(&type);
@@ -33385,6 +34692,7 @@ char HP_logs_chattype2char(e_log_chat_type type) {
 	char retVal___ = 0;
 	if( HPMHooks.count.HP_logs_chattype2char_pre ) {
 		char (*preHookFunc) (e_log_chat_type *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chattype2char_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_logs_chattype2char_pre[hIndex].func;
 			retVal___ = preHookFunc(&type);
@@ -33411,6 +34719,7 @@ bool HP_logs_should_log_item(int nameid, int amount, int refine, struct item_dat
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_logs_should_log_item_pre ) {
 		bool (*preHookFunc) (int *nameid, int *amount, int *refine, struct item_data *id);
+		*HPMforce_return = false;
 		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);
@@ -33437,6 +34746,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_clear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mail_clear_pre[hIndex].func;
 			preHookFunc(sd);
@@ -33463,6 +34773,7 @@ int HP_mail_removeitem(struct map_session_data *sd, short flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mail_removeitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, short *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removeitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mail_removeitem_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &flag);
@@ -33489,6 +34800,7 @@ int HP_mail_removezeny(struct map_session_data *sd, short flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mail_removezeny_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, short *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removezeny_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mail_removezeny_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &flag);
@@ -33515,6 +34827,7 @@ unsigned char HP_mail_setitem(struct map_session_data *sd, int idx, int amount)
 	unsigned char retVal___ = 0;
 	if( HPMHooks.count.HP_mail_setitem_pre ) {
 		unsigned char (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -33541,6 +34854,7 @@ bool HP_mail_setattachment(struct map_session_data *sd, struct mail_message *msg
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mail_setattachment_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, struct mail_message *msg);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setattachment_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mail_setattachment_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, msg);
@@ -33566,6 +34880,7 @@ void HP_mail_getattachment(struct map_session_data *sd, int zeny, struct item *i
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mail_getattachment_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *zeny, struct item *item);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_getattachment_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mail_getattachment_pre[hIndex].func;
 			preHookFunc(sd, &zeny, item);
@@ -33592,6 +34907,7 @@ int HP_mail_openmail(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mail_openmail_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_openmail_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mail_openmail_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -33617,6 +34933,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_deliveryfail_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mail_deliveryfail_pre[hIndex].func;
 			preHookFunc(sd, msg);
@@ -33643,6 +34960,7 @@ bool HP_mail_invalid_operation(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mail_invalid_operation_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -33669,6 +34987,7 @@ void HP_map_zone_init(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_zone_init_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_zone_init_pre[hIndex].func;
 			preHookFunc();
@@ -33694,6 +35013,7 @@ void HP_map_zone_remove(int m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_zone_remove_pre ) {
 		void (*preHookFunc) (int *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_remove_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_zone_remove_pre[hIndex].func;
 			preHookFunc(&m);
@@ -33719,6 +35039,7 @@ void HP_map_zone_apply(int m, struct map_zone_data *zone, const char *start, con
 	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);
+		*HPMforce_return = false;
 		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);
@@ -33744,6 +35065,7 @@ void HP_map_zone_change(int m, struct map_zone_data *zone, const char *start, co
 	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);
+		*HPMforce_return = false;
 		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);
@@ -33769,6 +35091,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -33795,6 +35118,7 @@ int HP_map_getcell(int16 m, int16 x, int16 y, cell_chk cellchk) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_getcell_pre ) {
 		int (*preHookFunc) (int16 *m, int16 *x, int16 *y, cell_chk *cellchk);
+		*HPMforce_return = false;
 		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);
@@ -33820,6 +35144,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -33845,6 +35170,7 @@ void HP_map_cellfromcache(struct map_data *m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_cellfromcache_pre ) {
 		void (*preHookFunc) (struct map_data *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cellfromcache_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_cellfromcache_pre[hIndex].func;
 			preHookFunc(m);
@@ -33870,6 +35196,7 @@ void HP_map_setusers(int p1) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_setusers_pre ) {
 		void (*preHookFunc) (int *p1);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setusers_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_setusers_pre[hIndex].func;
 			preHookFunc(&p1);
@@ -33896,6 +35223,7 @@ int HP_map_getusers(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_getusers_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getusers_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_getusers_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -33922,6 +35250,7 @@ int HP_map_usercount(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_usercount_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_usercount_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_usercount_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -33948,6 +35277,7 @@ int HP_map_freeblock(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_freeblock_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_freeblock_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -33974,6 +35304,7 @@ int HP_map_freeblock_lock(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_freeblock_lock_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_lock_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_freeblock_lock_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -34000,6 +35331,7 @@ int HP_map_freeblock_unlock(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_freeblock_unlock_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_unlock_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_freeblock_unlock_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -34026,6 +35358,7 @@ int HP_map_addblock(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_addblock_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addblock_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_addblock_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -34052,6 +35385,7 @@ int HP_map_delblock(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_delblock_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delblock_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_delblock_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -34078,6 +35412,7 @@ int HP_map_moveblock(struct block_list *bl, int x1, int y1, int64 tick) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_moveblock_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *x1, int *y1, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -34104,6 +35439,7 @@ int HP_map_count_oncell(int16 m, int16 x, int16 y, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_count_oncell_pre ) {
 		int (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *type);
+		*HPMforce_return = false;
 		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);
@@ -34130,6 +35466,7 @@ struct skill_unit* HP_map_find_skill_unit_oncell(struct block_list *target, int1
 	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);
+		*HPMforce_return = false;
 		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);
@@ -34156,6 +35493,7 @@ int HP_map_get_new_object_id(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_get_new_object_id_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -34182,6 +35520,7 @@ int HP_map_search_freecell(struct block_list *src, int16 m, int16 *x, int16 *y,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -34208,6 +35547,7 @@ int HP_map_quit(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_quit_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_quit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_quit_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -34234,6 +35574,7 @@ bool HP_map_addnpc(int16 m, struct npc_data *nd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_map_addnpc_pre ) {
 		bool (*preHookFunc) (int16 *m, struct npc_data *nd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnpc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_addnpc_pre[hIndex].func;
 			retVal___ = preHookFunc(&m, nd);
@@ -34260,6 +35601,7 @@ int HP_map_clearflooritem_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_clearflooritem_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -34286,6 +35628,7 @@ int HP_map_removemobs_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_removemobs_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -34311,6 +35654,7 @@ void HP_map_clearflooritem(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_clearflooritem_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_clearflooritem_pre[hIndex].func;
 			preHookFunc(bl);
@@ -34337,6 +35681,7 @@ int HP_map_addflooritem(struct item *item_data, int amount, int16 m, int16 x, in
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -34362,6 +35707,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnickdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_addnickdb_pre[hIndex].func;
 			preHookFunc(&charid, nick);
@@ -34387,6 +35733,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delnickdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_delnickdb_pre[hIndex].func;
 			preHookFunc(&charid, nick);
@@ -34412,6 +35759,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reqnickdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_reqnickdb_pre[hIndex].func;
 			preHookFunc(sd, &charid);
@@ -34438,6 +35786,7 @@ const char* HP_map_charid2nick(int charid) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_charid2nick_pre ) {
 		const char* (*preHookFunc) (int *charid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2nick_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_charid2nick_pre[hIndex].func;
 			retVal___ = preHookFunc(&charid);
@@ -34464,6 +35813,7 @@ struct map_session_data* HP_map_charid2sd(int charid) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_charid2sd_pre ) {
 		struct map_session_data* (*preHookFunc) (int *charid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2sd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_charid2sd_pre[hIndex].func;
 			retVal___ = preHookFunc(&charid);
@@ -34489,6 +35839,7 @@ void HP_map_vforeachpc(int ( *func ) (struct map_session_data *sd, 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);
+		*HPMforce_return = false;
 		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;
@@ -34520,6 +35871,7 @@ void HP_map_vforeachmob(int ( *func ) (struct mob_data *md, va_list args), va_li
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_vforeachmob_pre ) {
 		void (*preHookFunc) (int ( *func ) (struct mob_data *md, va_list args), va_list args);
+		*HPMforce_return = false;
 		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;
@@ -34551,6 +35903,7 @@ void HP_map_vforeachnpc(int ( *func ) (struct npc_data *nd, va_list args), va_li
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_vforeachnpc_pre ) {
 		void (*preHookFunc) (int ( *func ) (struct npc_data *nd, va_list args), va_list args);
+		*HPMforce_return = false;
 		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;
@@ -34582,6 +35935,7 @@ void HP_map_vforeachregen(int ( *func ) (struct block_list *bl, va_list args), v
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_vforeachregen_pre ) {
 		void (*preHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args);
+		*HPMforce_return = false;
 		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;
@@ -34613,6 +35967,7 @@ void HP_map_vforeachiddb(int ( *func ) (struct block_list *bl, va_list args), va
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_vforeachiddb_pre ) {
 		void (*preHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args);
+		*HPMforce_return = false;
 		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;
@@ -34645,6 +36000,7 @@ int HP_map_vforeachinrange(int ( *func ) (struct block_list *, va_list), struct
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -34677,6 +36033,7 @@ int HP_map_vforeachinshootrange(int ( *func ) (struct block_list *, va_list), st
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -34709,6 +36066,7 @@ int HP_map_vforeachinarea(int ( *func ) (struct block_list *, va_list), int16 m,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -34741,6 +36099,7 @@ int HP_map_vforcountinrange(int ( *func ) (struct block_list *, va_list), struct
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -34773,6 +36132,7 @@ int HP_map_vforcountinarea(int ( *func ) (struct block_list *, va_list), int16 m
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -34805,6 +36165,7 @@ int HP_map_vforeachinmovearea(int ( *func ) (struct block_list *, va_list), stru
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -34837,6 +36198,7 @@ int HP_map_vforeachincell(int ( *func ) (struct block_list *, va_list), int16 m,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -34869,6 +36231,7 @@ int HP_map_vforeachinpath(int ( *func ) (struct block_list *, va_list), int16 m,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -34901,6 +36264,7 @@ int HP_map_vforeachinmap(int ( *func ) (struct block_list *, va_list), int16 m,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_vforeachinmap_pre ) {
 		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *m, int *type, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -34933,6 +36297,7 @@ int HP_map_vforeachininstance(int ( *func ) (struct block_list *, va_list), int1
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_vforeachininstance_pre ) {
 		int (*preHookFunc) (int ( *func ) (struct block_list *, va_list), int16 *instance_id, int *type, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -34965,6 +36330,7 @@ struct map_session_data* HP_map_id2sd(int id) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_id2sd_pre ) {
 		struct map_session_data* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2sd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_id2sd_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -34991,6 +36357,7 @@ struct mob_data* HP_map_id2md(int id) {
 	struct mob_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_id2md_pre ) {
 		struct mob_data* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2md_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_id2md_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -35017,6 +36384,7 @@ struct npc_data* HP_map_id2nd(int id) {
 	struct npc_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_id2nd_pre ) {
 		struct npc_data* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2nd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_id2nd_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -35043,6 +36411,7 @@ struct homun_data* HP_map_id2hd(int id) {
 	struct homun_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_id2hd_pre ) {
 		struct homun_data* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2hd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_id2hd_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -35069,6 +36438,7 @@ struct mercenary_data* HP_map_id2mc(int id) {
 	struct mercenary_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_id2mc_pre ) {
 		struct mercenary_data* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2mc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_id2mc_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -35095,6 +36465,7 @@ struct chat_data* HP_map_id2cd(int id) {
 	struct chat_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_id2cd_pre ) {
 		struct chat_data* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2cd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_id2cd_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -35121,6 +36492,7 @@ struct block_list* HP_map_id2bl(int id) {
 	struct block_list* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_id2bl_pre ) {
 		struct block_list* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2bl_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_id2bl_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -35147,6 +36519,7 @@ bool HP_map_blid_exists(int id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_map_blid_exists_pre ) {
 		bool (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		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);
@@ -35173,6 +36546,7 @@ int16 HP_map_mapindex2mapid(unsigned short map_index) {
 	int16 retVal___ = 0;
 	if( HPMHooks.count.HP_map_mapindex2mapid_pre ) {
 		int16 (*preHookFunc) (unsigned short *map_index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapindex2mapid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_mapindex2mapid_pre[hIndex].func;
 			retVal___ = preHookFunc(&map_index);
@@ -35199,6 +36573,7 @@ int16 HP_map_mapname2mapid(const char *name) {
 	int16 retVal___ = 0;
 	if( HPMHooks.count.HP_map_mapname2mapid_pre ) {
 		int16 (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2mapid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_mapname2mapid_pre[hIndex].func;
 			retVal___ = preHookFunc(name);
@@ -35225,6 +36600,7 @@ int HP_map_mapname2ipport(unsigned short name, uint32 *ip, uint16 *port) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_mapname2ipport_pre ) {
 		int (*preHookFunc) (unsigned short *name, uint32 *ip, uint16 *port);
+		*HPMforce_return = false;
 		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);
@@ -35251,6 +36627,7 @@ int HP_map_setipport(unsigned short map_index, uint32 ip, uint16 port) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_setipport_pre ) {
 		int (*preHookFunc) (unsigned short *map_index, uint32 *ip, uint16 *port);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setipport_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_setipport_pre[hIndex].func;
 			retVal___ = preHookFunc(&map_index, &ip, &port);
@@ -35277,6 +36654,7 @@ int HP_map_eraseipport(unsigned short map_index, uint32 ip, uint16 port) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_eraseipport_pre ) {
 		int (*preHookFunc) (unsigned short *map_index, uint32 *ip, uint16 *port);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseipport_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_eraseipport_pre[hIndex].func;
 			retVal___ = preHookFunc(&map_index, &ip, &port);
@@ -35303,6 +36681,7 @@ int HP_map_eraseallipport(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_eraseallipport_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_eraseallipport_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -35328,6 +36707,7 @@ void HP_map_addiddb(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_addiddb_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addiddb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_addiddb_pre[hIndex].func;
 			preHookFunc(bl);
@@ -35353,6 +36733,7 @@ void HP_map_deliddb(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_deliddb_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_deliddb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_deliddb_pre[hIndex].func;
 			preHookFunc(bl);
@@ -35379,6 +36760,7 @@ struct map_session_data* HP_map_nick2sd(const char *nick) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_nick2sd_pre ) {
 		struct map_session_data* (*preHookFunc) (const char *nick);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick2sd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_nick2sd_pre[hIndex].func;
 			retVal___ = preHookFunc(nick);
@@ -35405,6 +36787,7 @@ struct mob_data* HP_map_getmob_boss(int16 m) {
 	struct mob_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_getmob_boss_pre ) {
 		struct mob_data* (*preHookFunc) (int16 *m);
+		*HPMforce_return = false;
 		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);
@@ -35431,6 +36814,7 @@ struct mob_data* HP_map_id2boss(int id) {
 	struct mob_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_id2boss_pre ) {
 		struct mob_data* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2boss_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_id2boss_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -35456,6 +36840,7 @@ void HP_map_reloadnpc(bool clear, const char *const *extra_scripts, int extra_sc
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_reloadnpc_pre ) {
 		void (*preHookFunc) (bool *clear, const char *const *extra_scripts, int *extra_scripts_count);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_reloadnpc_pre[hIndex].func;
 			preHookFunc(&clear, extra_scripts, &extra_scripts_count);
@@ -35482,6 +36867,7 @@ int HP_map_check_dir(int s_dir, int t_dir) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_check_dir_pre ) {
 		int (*preHookFunc) (int *s_dir, int *t_dir);
+		*HPMforce_return = false;
 		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);
@@ -35508,6 +36894,7 @@ uint8 HP_map_calc_dir(struct block_list *src, int16 x, int16 y) {
 	uint8 retVal___ = 0;
 	if( HPMHooks.count.HP_map_calc_dir_pre ) {
 		uint8 (*preHookFunc) (struct block_list *src, int16 *x, int16 *y);
+		*HPMforce_return = false;
 		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);
@@ -35534,6 +36921,7 @@ int HP_map_random_dir(struct block_list *bl, short *x, short *y) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_random_dir_pre ) {
 		int (*preHookFunc) (struct block_list *bl, short *x, short *y);
+		*HPMforce_return = false;
 		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);
@@ -35560,6 +36948,7 @@ int HP_map_cleanup_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_cleanup_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -35592,6 +36981,7 @@ int HP_map_delmap(char *mapname) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_delmap_pre ) {
 		int (*preHookFunc) (char *mapname);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_delmap_pre[hIndex].func;
 			retVal___ = preHookFunc(mapname);
@@ -35617,6 +37007,7 @@ void HP_map_flags_init(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_flags_init_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_flags_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_flags_init_pre[hIndex].func;
 			preHookFunc();
@@ -35643,6 +37034,7 @@ bool HP_map_iwall_set(int16 m, int16 x, int16 y, int size, int8 dir, bool shoota
 	bool retVal___ = false;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -35668,6 +37060,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_get_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_iwall_get_pre[hIndex].func;
 			preHookFunc(sd);
@@ -35693,6 +37086,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -35719,6 +37113,7 @@ int HP_map_addmobtolist(unsigned short m, struct spawn_data *spawn) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_addmobtolist_pre ) {
 		int (*preHookFunc) (unsigned short *m, struct spawn_data *spawn);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmobtolist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_addmobtolist_pre[hIndex].func;
 			retVal___ = preHookFunc(&m, spawn);
@@ -35744,6 +37139,7 @@ void HP_map_spawnmobs(int16 m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_spawnmobs_pre ) {
 		void (*preHookFunc) (int16 *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_spawnmobs_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_spawnmobs_pre[hIndex].func;
 			preHookFunc(&m);
@@ -35769,6 +37165,7 @@ void HP_map_removemobs(int16 m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_removemobs_pre ) {
 		void (*preHookFunc) (int16 *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_removemobs_pre[hIndex].func;
 			preHookFunc(&m);
@@ -35794,6 +37191,7 @@ void HP_map_addmap2db(struct map_data *m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_addmap2db_pre ) {
 		void (*preHookFunc) (struct map_data *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap2db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_addmap2db_pre[hIndex].func;
 			preHookFunc(m);
@@ -35819,6 +37217,7 @@ void HP_map_removemapdb(struct map_data *m) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_removemapdb_pre ) {
 		void (*preHookFunc) (struct map_data *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemapdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_removemapdb_pre[hIndex].func;
 			preHookFunc(m);
@@ -35844,6 +37243,7 @@ void HP_map_clean(int i) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_clean_pre ) {
 		void (*preHookFunc) (int *i);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clean_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_clean_pre[hIndex].func;
 			preHookFunc(&i);
@@ -35869,6 +37269,7 @@ void HP_map_do_shutdown(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_do_shutdown_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_do_shutdown_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_do_shutdown_pre[hIndex].func;
 			preHookFunc();
@@ -35895,6 +37296,7 @@ int HP_map_freeblock_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_freeblock_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -35921,6 +37323,7 @@ int HP_map_searchrandfreecell(int16 m, int16 *x, int16 *y, int stack) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_searchrandfreecell_pre ) {
 		int (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *stack);
+		*HPMforce_return = false;
 		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);
@@ -35947,6 +37350,7 @@ int HP_map_count_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_count_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -35980,6 +37384,7 @@ DBData HP_map_create_charid2nick(DBKey key, va_list args) {
 	memset(&retVal___, '\0', sizeof(DBData));
 	if( HPMHooks.count.HP_map_create_charid2nick_pre ) {
 		DBData (*preHookFunc) (DBKey *key, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -36012,6 +37417,7 @@ int HP_map_removemobs_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_removemobs_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -36045,6 +37451,7 @@ struct mapcell HP_map_gat2cell(int gat) {
 	memset(&retVal___, '\0', sizeof(struct mapcell));
 	if( HPMHooks.count.HP_map_gat2cell_pre ) {
 		struct mapcell (*preHookFunc) (int *gat);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_gat2cell_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_gat2cell_pre[hIndex].func;
 			retVal___ = preHookFunc(&gat);
@@ -36071,6 +37478,7 @@ int HP_map_cell2gat(struct mapcell cell) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_cell2gat_pre ) {
 		int (*preHookFunc) (struct mapcell *cell);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cell2gat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_cell2gat_pre[hIndex].func;
 			retVal___ = preHookFunc(&cell);
@@ -36097,6 +37505,7 @@ int HP_map_getcellp(struct map_data *m, int16 x, int16 y, cell_chk cellchk) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_getcellp_pre ) {
 		int (*preHookFunc) (struct map_data *m, int16 *x, int16 *y, cell_chk *cellchk);
+		*HPMforce_return = false;
 		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);
@@ -36122,6 +37531,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -36148,6 +37558,7 @@ int HP_map_sub_getcellp(struct map_data *m, int16 x, int16 y, cell_chk cellchk)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_sub_getcellp_pre ) {
 		int (*preHookFunc) (struct map_data *m, int16 *x, int16 *y, cell_chk *cellchk);
+		*HPMforce_return = false;
 		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);
@@ -36173,6 +37584,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -36198,6 +37610,7 @@ void HP_map_iwall_nextxy(int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 *
 	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);
+		*HPMforce_return = false;
 		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);
@@ -36225,6 +37638,7 @@ DBData HP_map_create_map_data_other_server(DBKey key, va_list args) {
 	memset(&retVal___, '\0', sizeof(DBData));
 	if( HPMHooks.count.HP_map_create_map_data_other_server_pre ) {
 		DBData (*preHookFunc) (DBKey *key, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -36257,6 +37671,7 @@ int HP_map_eraseallipport_sub(DBKey key, DBData *data, va_list va) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_eraseallipport_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list va);
+		*HPMforce_return = false;
 		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;
@@ -36289,6 +37704,7 @@ char* HP_map_init_mapcache(FILE *fp) {
 	char* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_init_mapcache_pre ) {
 		char* (*preHookFunc) (FILE *fp);
+		*HPMforce_return = false;
 		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);
@@ -36315,6 +37731,7 @@ int HP_map_readfromcache(struct map_data *m, char *buffer) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_readfromcache_pre ) {
 		int (*preHookFunc) (struct map_data *m, char *buffer);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readfromcache_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_readfromcache_pre[hIndex].func;
 			retVal___ = preHookFunc(m, buffer);
@@ -36341,6 +37758,7 @@ int HP_map_addmap(const char *mapname) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_addmap_pre ) {
 		int (*preHookFunc) (const char *mapname);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_addmap_pre[hIndex].func;
 			retVal___ = preHookFunc(mapname);
@@ -36366,6 +37784,7 @@ void HP_map_delmapid(int id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_delmapid_pre ) {
 		void (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmapid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_delmapid_pre[hIndex].func;
 			preHookFunc(&id);
@@ -36391,6 +37810,7 @@ void HP_map_zone_db_clear(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_zone_db_clear_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -36416,6 +37836,7 @@ void HP_map_list_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_list_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_list_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_list_final_pre[hIndex].func;
 			preHookFunc();
@@ -36442,6 +37863,7 @@ int HP_map_waterheight(char *mapname) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_waterheight_pre ) {
 		int (*preHookFunc) (char *mapname);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_waterheight_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_waterheight_pre[hIndex].func;
 			retVal___ = preHookFunc(mapname);
@@ -36468,6 +37890,7 @@ int HP_map_readgat(struct map_data *m) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_readgat_pre ) {
 		int (*preHookFunc) (struct map_data *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readgat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_readgat_pre[hIndex].func;
 			retVal___ = preHookFunc(m);
@@ -36494,6 +37917,7 @@ int HP_map_readallmaps(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_readallmaps_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readallmaps_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_readallmaps_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -36520,6 +37944,7 @@ int HP_map_config_read(char *cfgName) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_config_read_pre ) {
 		int (*preHookFunc) (char *cfgName);
+		*HPMforce_return = false;
 		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);
@@ -36546,6 +37971,7 @@ int HP_map_config_read_sub(char *cfgName) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_config_read_sub_pre ) {
 		int (*preHookFunc) (char *cfgName);
+		*HPMforce_return = false;
 		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);
@@ -36571,6 +37997,7 @@ void HP_map_reloadnpc_sub(char *cfgName) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_reloadnpc_sub_pre ) {
 		void (*preHookFunc) (char *cfgName);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_sub_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_reloadnpc_sub_pre[hIndex].func;
 			preHookFunc(cfgName);
@@ -36597,6 +38024,7 @@ int HP_map_inter_config_read(char *cfgName) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_inter_config_read_pre ) {
 		int (*preHookFunc) (char *cfgName);
+		*HPMforce_return = false;
 		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);
@@ -36623,6 +38051,7 @@ int HP_map_sql_init(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_sql_init_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sql_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_sql_init_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -36649,6 +38078,7 @@ int HP_map_sql_close(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_sql_close_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sql_close_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_sql_close_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -36675,6 +38105,7 @@ bool HP_map_zone_mf_cache(int m, char *flag, char *params) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_map_zone_mf_cache_pre ) {
 		bool (*preHookFunc) (int *m, char *flag, char *params);
+		*HPMforce_return = false;
 		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);
@@ -36701,6 +38132,7 @@ unsigned short HP_map_zone_str2itemid(const char *name) {
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_map_zone_str2itemid_pre ) {
 		unsigned short (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		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);
@@ -36727,6 +38159,7 @@ unsigned short HP_map_zone_str2skillid(const char *name) {
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_map_zone_str2skillid_pre ) {
 		unsigned short (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		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);
@@ -36753,6 +38186,7 @@ enum bl_type HP_map_zone_bl_type(const char *entry, enum map_zone_skill_subtype
 	enum bl_type retVal___ = BL_NUL;
 	if( HPMHooks.count.HP_map_zone_bl_type_pre ) {
 		enum bl_type (*preHookFunc) (const char *entry, enum map_zone_skill_subtype *subtype);
+		*HPMforce_return = false;
 		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);
@@ -36778,6 +38212,7 @@ void HP_map_read_zone_db(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_read_zone_db_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -36804,6 +38239,7 @@ int HP_map_db_final(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_db_final_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -36836,6 +38272,7 @@ int HP_map_nick_db_final(DBKey key, DBData *data, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_nick_db_final_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -36868,6 +38305,7 @@ int HP_map_cleanup_db_sub(DBKey key, DBData *data, va_list va) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_cleanup_db_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list va);
+		*HPMforce_return = false;
 		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;
@@ -36900,6 +38338,7 @@ int HP_map_abort_sub(struct map_session_data *sd, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_abort_sub_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -36931,6 +38370,7 @@ void HP_map_helpscreen(bool do_exit) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_helpscreen_pre ) {
 		void (*preHookFunc) (bool *do_exit);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_helpscreen_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_helpscreen_pre[hIndex].func;
 			preHookFunc(&do_exit);
@@ -36956,6 +38396,7 @@ void HP_map_versionscreen(bool do_exit) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_versionscreen_pre ) {
 		void (*preHookFunc) (bool *do_exit);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_versionscreen_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_versionscreen_pre[hIndex].func;
 			preHookFunc(&do_exit);
@@ -36982,6 +38423,7 @@ bool HP_map_arg_next_value(const char *option, int i, int argc, bool must) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_map_arg_next_value_pre ) {
 		bool (*preHookFunc) (const char *option, int *i, int *argc, bool *must);
+		*HPMforce_return = false;
 		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, &must);
@@ -37007,6 +38449,7 @@ void HP_map_addblcell(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_addblcell_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addblcell_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_addblcell_pre[hIndex].func;
 			preHookFunc(bl);
@@ -37032,6 +38475,7 @@ void HP_map_delblcell(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_delblcell_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delblcell_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_delblcell_pre[hIndex].func;
 			preHookFunc(bl);
@@ -37058,6 +38502,7 @@ int HP_map_get_new_bonus_id(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_map_get_new_bonus_id_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_get_new_bonus_id_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_get_new_bonus_id_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -37083,6 +38528,7 @@ void HP_map_add_questinfo(int m, struct questinfo *qi) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_map_add_questinfo_pre ) {
 		void (*preHookFunc) (int *m, struct questinfo *qi);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_add_questinfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_add_questinfo_pre[hIndex].func;
 			preHookFunc(&m, qi);
@@ -37109,6 +38555,7 @@ bool HP_map_remove_questinfo(int m, struct npc_data *nd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_map_remove_questinfo_pre ) {
 		bool (*preHookFunc) (int *m, struct npc_data *nd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_remove_questinfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_remove_questinfo_pre[hIndex].func;
 			retVal___ = preHookFunc(&m, nd);
@@ -37135,6 +38582,7 @@ struct map_zone_data* HP_map_merge_zone(struct map_zone_data *main, struct map_z
 	struct map_zone_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_map_merge_zone_pre ) {
 		struct map_zone_data* (*preHookFunc) (struct map_zone_data *main, struct map_zone_data *other);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_merge_zone_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_map_merge_zone_pre[hIndex].func;
 			retVal___ = preHookFunc(main, other);
@@ -37162,6 +38610,7 @@ struct s_mapiterator* HP_mapit_alloc(enum e_mapitflags flags, enum bl_type types
 	struct s_mapiterator* retVal___ = NULL;
 	if( HPMHooks.count.HP_mapit_alloc_pre ) {
 		struct s_mapiterator* (*preHookFunc) (enum e_mapitflags *flags, enum bl_type *types);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_alloc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapit_alloc_pre[hIndex].func;
 			retVal___ = preHookFunc(&flags, &types);
@@ -37187,6 +38636,7 @@ void HP_mapit_free(struct s_mapiterator *iter) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mapit_free_pre ) {
 		void (*preHookFunc) (struct s_mapiterator *iter);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_free_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapit_free_pre[hIndex].func;
 			preHookFunc(iter);
@@ -37213,6 +38663,7 @@ struct block_list* HP_mapit_first(struct s_mapiterator *iter) {
 	struct block_list* retVal___ = NULL;
 	if( HPMHooks.count.HP_mapit_first_pre ) {
 		struct block_list* (*preHookFunc) (struct s_mapiterator *iter);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_first_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapit_first_pre[hIndex].func;
 			retVal___ = preHookFunc(iter);
@@ -37239,6 +38690,7 @@ struct block_list* HP_mapit_last(struct s_mapiterator *iter) {
 	struct block_list* retVal___ = NULL;
 	if( HPMHooks.count.HP_mapit_last_pre ) {
 		struct block_list* (*preHookFunc) (struct s_mapiterator *iter);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_last_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapit_last_pre[hIndex].func;
 			retVal___ = preHookFunc(iter);
@@ -37265,6 +38717,7 @@ struct block_list* HP_mapit_next(struct s_mapiterator *iter) {
 	struct block_list* retVal___ = NULL;
 	if( HPMHooks.count.HP_mapit_next_pre ) {
 		struct block_list* (*preHookFunc) (struct s_mapiterator *iter);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_next_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapit_next_pre[hIndex].func;
 			retVal___ = preHookFunc(iter);
@@ -37291,6 +38744,7 @@ struct block_list* HP_mapit_prev(struct s_mapiterator *iter) {
 	struct block_list* retVal___ = NULL;
 	if( HPMHooks.count.HP_mapit_prev_pre ) {
 		struct block_list* (*preHookFunc) (struct s_mapiterator *iter);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_prev_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapit_prev_pre[hIndex].func;
 			retVal___ = preHookFunc(iter);
@@ -37317,6 +38771,7 @@ bool HP_mapit_exists(struct s_mapiterator *iter) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mapit_exists_pre ) {
 		bool (*preHookFunc) (struct s_mapiterator *iter);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_exists_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapit_exists_pre[hIndex].func;
 			retVal___ = preHookFunc(iter);
@@ -37343,6 +38798,7 @@ void HP_mapreg_init(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mapreg_init_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_init_pre[hIndex].func;
 			preHookFunc();
@@ -37368,6 +38824,7 @@ void HP_mapreg_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mapreg_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_final_pre[hIndex].func;
 			preHookFunc();
@@ -37394,6 +38851,7 @@ int HP_mapreg_readreg(int64 uid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mapreg_readreg_pre ) {
 		int (*preHookFunc) (int64 *uid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readreg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_readreg_pre[hIndex].func;
 			retVal___ = preHookFunc(&uid);
@@ -37420,6 +38878,7 @@ char* HP_mapreg_readregstr(int64 uid) {
 	char* retVal___ = NULL;
 	if( HPMHooks.count.HP_mapreg_readregstr_pre ) {
 		char* (*preHookFunc) (int64 *uid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readregstr_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_readregstr_pre[hIndex].func;
 			retVal___ = preHookFunc(&uid);
@@ -37446,6 +38905,7 @@ bool HP_mapreg_setreg(int64 uid, int val) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mapreg_setreg_pre ) {
 		bool (*preHookFunc) (int64 *uid, int *val);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setreg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_setreg_pre[hIndex].func;
 			retVal___ = preHookFunc(&uid, &val);
@@ -37472,6 +38932,7 @@ bool HP_mapreg_setregstr(int64 uid, const char *str) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mapreg_setregstr_pre ) {
 		bool (*preHookFunc) (int64 *uid, const char *str);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setregstr_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_setregstr_pre[hIndex].func;
 			retVal___ = preHookFunc(&uid, str);
@@ -37497,6 +38958,7 @@ void HP_mapreg_load(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mapreg_load_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_load_pre[hIndex].func;
 			preHookFunc();
@@ -37522,6 +38984,7 @@ void HP_mapreg_save(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mapreg_save_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_save_pre[hIndex].func;
 			preHookFunc();
@@ -37548,6 +39011,7 @@ int HP_mapreg_save_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mapreg_save_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -37574,6 +39038,7 @@ int HP_mapreg_destroyreg(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mapreg_destroyreg_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_destroyreg_pre; hIndex++ ) {
 			va_list ap___copy; va_copy(ap___copy, ap);
 			preHookFunc = HPMHooks.list.HP_mapreg_destroyreg_pre[hIndex].func;
@@ -37605,6 +39070,7 @@ void HP_mapreg_reload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mapreg_reload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mapreg_reload_pre[hIndex].func;
 			preHookFunc();
@@ -37631,6 +39097,7 @@ bool HP_mapreg_config_read(const char *w1, const char *w2) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mapreg_config_read_pre ) {
 		bool (*preHookFunc) (const char *w1, const char *w2);
+		*HPMforce_return = false;
 		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);
@@ -37657,6 +39124,7 @@ void HP_mercenary_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mercenary_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -37683,6 +39151,7 @@ bool HP_mercenary_class(int class_) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mercenary_class_pre ) {
 		bool (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_class_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_class_pre[hIndex].func;
 			retVal___ = preHookFunc(&class_);
@@ -37709,6 +39178,7 @@ struct view_data* HP_mercenary_get_viewdata(int class_) {
 	struct view_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_mercenary_get_viewdata_pre ) {
 		struct view_data* (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -37735,6 +39205,7 @@ int HP_mercenary_create(struct map_session_data *sd, int class_, unsigned int li
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_create_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *class_, unsigned int *lifetime);
+		*HPMforce_return = false;
 		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);
@@ -37761,6 +39232,7 @@ int HP_mercenary_data_received(struct s_mercenary *merc, bool flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_data_received_pre ) {
 		int (*preHookFunc) (struct s_mercenary *merc, bool *flag);
+		*HPMforce_return = false;
 		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);
@@ -37787,6 +39259,7 @@ int HP_mercenary_save(struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_save_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_save_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_save_pre[hIndex].func;
 			retVal___ = preHookFunc(md);
@@ -37812,6 +39285,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_heal_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_heal_pre[hIndex].func;
 			preHookFunc(md, &hp, &sp);
@@ -37838,6 +39312,7 @@ int HP_mercenary_dead(struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_dead_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_dead_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_dead_pre[hIndex].func;
 			retVal___ = preHookFunc(md);
@@ -37864,6 +39339,7 @@ int HP_mercenary_delete(struct mercenary_data *md, int reply) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_delete_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md, int *reply);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_delete_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_delete_pre[hIndex].func;
 			retVal___ = preHookFunc(md, &reply);
@@ -37889,6 +39365,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_stop_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_contract_stop_pre[hIndex].func;
 			preHookFunc(md);
@@ -37915,6 +39392,7 @@ int HP_mercenary_get_lifetime(struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_get_lifetime_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md);
+		*HPMforce_return = false;
 		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);
@@ -37941,6 +39419,7 @@ int HP_mercenary_get_guild(struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_get_guild_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md);
+		*HPMforce_return = false;
 		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);
@@ -37967,6 +39446,7 @@ int HP_mercenary_get_faith(struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_get_faith_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md);
+		*HPMforce_return = false;
 		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);
@@ -37993,6 +39473,7 @@ int HP_mercenary_set_faith(struct mercenary_data *md, int value) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_set_faith_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md, int *value);
+		*HPMforce_return = false;
 		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);
@@ -38019,6 +39500,7 @@ int HP_mercenary_get_calls(struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_get_calls_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md);
+		*HPMforce_return = false;
 		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);
@@ -38045,6 +39527,7 @@ int HP_mercenary_set_calls(struct mercenary_data *md, int value) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_set_calls_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md, int *value);
+		*HPMforce_return = false;
 		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);
@@ -38071,6 +39554,7 @@ int HP_mercenary_kills(struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_kills_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_kills_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_kills_pre[hIndex].func;
 			retVal___ = preHookFunc(md);
@@ -38097,6 +39581,7 @@ int HP_mercenary_checkskill(struct mercenary_data *md, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_checkskill_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -38123,6 +39608,7 @@ int HP_mercenary_read_db(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_read_db_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_read_db_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -38149,6 +39635,7 @@ int HP_mercenary_read_skilldb(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_read_skilldb_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skilldb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_read_skilldb_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -38175,6 +39662,7 @@ int HP_mercenary_killbonus(struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_killbonus_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_killbonus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mercenary_killbonus_pre[hIndex].func;
 			retVal___ = preHookFunc(md);
@@ -38201,6 +39689,7 @@ int HP_mercenary_search_index(int class_) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_search_index_pre ) {
 		int (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -38227,6 +39716,7 @@ int HP_mercenary_contract_end_timer(int tid, int64 tick, int id, intptr_t data)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mercenary_contract_end_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -38253,6 +39743,7 @@ bool HP_mercenary_read_db_sub(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mercenary_read_db_sub_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -38279,6 +39770,7 @@ bool HP_mercenary_read_skill_db_sub(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mercenary_read_skill_db_sub_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -38306,6 +39798,7 @@ int HP_mob_init(bool mimimal) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_init_pre ) {
 		int (*preHookFunc) (bool *mimimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_init_pre[hIndex].func;
 			retVal___ = preHookFunc(&mimimal);
@@ -38332,6 +39825,7 @@ int HP_mob_final(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_final_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_final_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -38357,6 +39851,7 @@ void HP_mob_reload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mob_reload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_reload_pre[hIndex].func;
 			preHookFunc();
@@ -38383,6 +39878,7 @@ struct mob_db* HP_mob_db(int index) {
 	struct mob_db* retVal___ = NULL;
 	if( HPMHooks.count.HP_mob_db_pre ) {
 		struct mob_db* (*preHookFunc) (int *index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_db_pre[hIndex].func;
 			retVal___ = preHookFunc(&index);
@@ -38409,6 +39905,7 @@ struct mob_chat* HP_mob_chat(short id) {
 	struct mob_chat* retVal___ = NULL;
 	if( HPMHooks.count.HP_mob_chat_pre ) {
 		struct mob_chat* (*preHookFunc) (short *id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_chat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_chat_pre[hIndex].func;
 			retVal___ = preHookFunc(&id);
@@ -38435,6 +39932,7 @@ int HP_mob_makedummymobdb(int p1) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_makedummymobdb_pre ) {
 		int (*preHookFunc) (int *p1);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_makedummymobdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_makedummymobdb_pre[hIndex].func;
 			retVal___ = preHookFunc(&p1);
@@ -38461,6 +39959,7 @@ int HP_mob_spawn_guardian_sub(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_spawn_guardian_sub_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -38487,6 +39986,7 @@ int HP_mob_skill_id2skill_idx(int class_, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_skill_id2skill_idx_pre ) {
 		int (*preHookFunc) (int *class_, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -38513,6 +40013,7 @@ int HP_mob_db_searchname(const char *str) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_db_searchname_pre ) {
 		int (*preHookFunc) (const char *str);
+		*HPMforce_return = false;
 		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);
@@ -38539,6 +40040,7 @@ int HP_mob_db_searchname_array_sub(struct mob_db *monster, const char *str, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_db_searchname_array_sub_pre ) {
 		int (*preHookFunc) (struct mob_db *monster, const char *str, int *flag);
+		*HPMforce_return = false;
 		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(monster, str, &flag);
@@ -38564,6 +40066,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -38589,6 +40092,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_destroy_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_mvptomb_destroy_pre[hIndex].func;
 			preHookFunc(md);
@@ -38615,6 +40119,7 @@ int HP_mob_db_searchname_array(struct mob_db **data, int size, const char *str,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_db_searchname_array_pre ) {
 		int (*preHookFunc) (struct mob_db **data, int *size, const char *str, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -38641,6 +40146,7 @@ int HP_mob_db_checkid(const int id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_db_checkid_pre ) {
 		int (*preHookFunc) (const int *id);
+		*HPMforce_return = false;
 		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);
@@ -38667,6 +40173,7 @@ struct view_data* HP_mob_get_viewdata(int class_) {
 	struct view_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_mob_get_viewdata_pre ) {
 		struct view_data* (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -38693,6 +40200,7 @@ int HP_mob_parse_dataset(struct spawn_data *data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_parse_dataset_pre ) {
 		int (*preHookFunc) (struct spawn_data *data);
+		*HPMforce_return = false;
 		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);
@@ -38719,6 +40227,7 @@ struct mob_data* HP_mob_spawn_dataset(struct spawn_data *data) {
 	struct mob_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_mob_spawn_dataset_pre ) {
 		struct mob_data* (*preHookFunc) (struct spawn_data *data);
+		*HPMforce_return = false;
 		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);
@@ -38745,6 +40254,7 @@ int HP_mob_get_random_id(int type, int flag, int lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_get_random_id_pre ) {
 		int (*preHookFunc) (int *type, int *flag, int *lv);
+		*HPMforce_return = false;
 		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);
@@ -38771,6 +40281,7 @@ bool HP_mob_ksprotected(struct block_list *src, struct block_list *target) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_ksprotected_pre ) {
 		bool (*preHookFunc) (struct block_list *src, struct block_list *target);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ksprotected_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_ksprotected_pre[hIndex].func;
 			retVal___ = preHookFunc(src, target);
@@ -38797,6 +40308,7 @@ struct mob_data* HP_mob_once_spawn_sub(struct block_list *bl, int16 m, int16 x,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -38823,6 +40335,7 @@ int HP_mob_once_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, co
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -38849,6 +40362,7 @@ int HP_mob_once_spawn_area(struct map_session_data *sd, int16 m, int16 x0, int16
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -38875,6 +40389,7 @@ int HP_mob_spawn_guardian(const char *mapname, short x, short y, const char *mob
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -38901,6 +40416,7 @@ int HP_mob_spawn_bg(const char *mapname, short x, short y, const char *mobname,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -38927,6 +40443,7 @@ int HP_mob_can_reach(struct mob_data *md, struct block_list *bl, int range, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_can_reach_pre ) {
 		int (*preHookFunc) (struct mob_data *md, struct block_list *bl, int *range, int *state);
+		*HPMforce_return = false;
 		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);
@@ -38953,6 +40470,7 @@ int HP_mob_linksearch(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_linksearch_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -38985,6 +40503,7 @@ int HP_mob_delayspawn(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_delayspawn_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -39011,6 +40530,7 @@ int HP_mob_setdelayspawn(struct mob_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_setdelayspawn_pre ) {
 		int (*preHookFunc) (struct mob_data *md);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdelayspawn_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_setdelayspawn_pre[hIndex].func;
 			retVal___ = preHookFunc(md);
@@ -39037,6 +40557,7 @@ int HP_mob_count_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_count_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39069,6 +40590,7 @@ int HP_mob_spawn(struct mob_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_spawn_pre ) {
 		int (*preHookFunc) (struct mob_data *md);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_spawn_pre[hIndex].func;
 			retVal___ = preHookFunc(md);
@@ -39095,6 +40617,7 @@ int HP_mob_can_changetarget(struct mob_data *md, struct block_list *target, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_can_changetarget_pre ) {
 		int (*preHookFunc) (struct mob_data *md, struct block_list *target, int *mode);
+		*HPMforce_return = false;
 		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);
@@ -39121,6 +40644,7 @@ int HP_mob_target(struct mob_data *md, struct block_list *bl, int dist) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_target_pre ) {
 		int (*preHookFunc) (struct mob_data *md, struct block_list *bl, int *dist);
+		*HPMforce_return = false;
 		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);
@@ -39147,6 +40671,7 @@ int HP_mob_ai_sub_hard_activesearch(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_sub_hard_activesearch_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39179,6 +40704,7 @@ int HP_mob_ai_sub_hard_changechase(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_sub_hard_changechase_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39211,6 +40737,7 @@ int HP_mob_ai_sub_hard_bg_ally(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39243,6 +40770,7 @@ int HP_mob_ai_sub_hard_lootsearch(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39275,6 +40803,7 @@ int HP_mob_warpchase_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_warpchase_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39307,6 +40836,7 @@ int HP_mob_ai_sub_hard_slavemob(struct mob_data *md, int64 tick) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_sub_hard_slavemob_pre ) {
 		int (*preHookFunc) (struct mob_data *md, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -39333,6 +40863,7 @@ int HP_mob_unlocktarget(struct mob_data *md, int64 tick) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_unlocktarget_pre ) {
 		int (*preHookFunc) (struct mob_data *md, int64 *tick);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_unlocktarget_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_unlocktarget_pre[hIndex].func;
 			retVal___ = preHookFunc(md, &tick);
@@ -39359,6 +40890,7 @@ int HP_mob_randomwalk(struct mob_data *md, int64 tick) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_randomwalk_pre ) {
 		int (*preHookFunc) (struct mob_data *md, int64 *tick);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_randomwalk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_randomwalk_pre[hIndex].func;
 			retVal___ = preHookFunc(md, &tick);
@@ -39385,6 +40917,7 @@ int HP_mob_warpchase(struct mob_data *md, struct block_list *target) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_warpchase_pre ) {
 		int (*preHookFunc) (struct mob_data *md, struct block_list *target);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_warpchase_pre[hIndex].func;
 			retVal___ = preHookFunc(md, target);
@@ -39411,6 +40944,7 @@ bool HP_mob_ai_sub_hard(struct mob_data *md, int64 tick) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_ai_sub_hard_pre ) {
 		bool (*preHookFunc) (struct mob_data *md, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -39437,6 +40971,7 @@ int HP_mob_ai_sub_hard_timer(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_sub_hard_timer_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39469,6 +41004,7 @@ int HP_mob_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_sub_foreachclient_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39501,6 +41037,7 @@ int HP_mob_ai_sub_lazy(struct mob_data *md, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_sub_lazy_pre ) {
 		int (*preHookFunc) (struct mob_data *md, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -39533,6 +41070,7 @@ int HP_mob_ai_lazy(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_lazy_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -39559,6 +41097,7 @@ int HP_mob_ai_hard(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_ai_hard_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -39585,6 +41124,7 @@ struct item_drop* HP_mob_setdropitem(int nameid, int qty, struct item_data *data
 	struct item_drop* retVal___ = NULL;
 	if( HPMHooks.count.HP_mob_setdropitem_pre ) {
 		struct item_drop* (*preHookFunc) (int *nameid, int *qty, struct item_data *data);
+		*HPMforce_return = false;
 		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);
@@ -39611,6 +41151,7 @@ struct item_drop* HP_mob_setlootitem(struct item *item) {
 	struct item_drop* retVal___ = NULL;
 	if( HPMHooks.count.HP_mob_setlootitem_pre ) {
 		struct item_drop* (*preHookFunc) (struct item *item);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setlootitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_setlootitem_pre[hIndex].func;
 			retVal___ = preHookFunc(item);
@@ -39637,6 +41178,7 @@ int HP_mob_delay_item_drop(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_delay_item_drop_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -39662,6 +41204,7 @@ void HP_mob_item_drop(struct mob_data *md, struct item_drop_list *dlist, struct
 	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);
+		*HPMforce_return = false;
 		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);
@@ -39688,6 +41231,7 @@ int HP_mob_timer_delete(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_timer_delete_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -39714,6 +41258,7 @@ int HP_mob_deleteslave_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_deleteslave_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -39746,6 +41291,7 @@ int HP_mob_deleteslave(struct mob_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_deleteslave_pre ) {
 		int (*preHookFunc) (struct mob_data *md);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_deleteslave_pre[hIndex].func;
 			retVal___ = preHookFunc(md);
@@ -39772,6 +41318,7 @@ int HP_mob_respawn(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_respawn_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -39797,6 +41344,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -39822,6 +41370,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_damage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_damage_pre[hIndex].func;
 			preHookFunc(md, src, &damage);
@@ -39848,6 +41397,7 @@ int HP_mob_dead(struct mob_data *md, struct block_list *src, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_dead_pre ) {
 		int (*preHookFunc) (struct mob_data *md, struct block_list *src, int *type);
+		*HPMforce_return = false;
 		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);
@@ -39873,6 +41423,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_revive_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_revive_pre[hIndex].func;
 			preHookFunc(md, &hp);
@@ -39899,6 +41450,7 @@ int HP_mob_guardian_guildchange(struct mob_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_guardian_guildchange_pre ) {
 		int (*preHookFunc) (struct mob_data *md);
+		*HPMforce_return = false;
 		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);
@@ -39925,6 +41477,7 @@ int HP_mob_random_class(int *value, size_t count) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_random_class_pre ) {
 		int (*preHookFunc) (int *value, size_t *count);
+		*HPMforce_return = false;
 		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);
@@ -39951,6 +41504,7 @@ int HP_mob_class_change(struct mob_data *md, int class_) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_class_change_pre ) {
 		int (*preHookFunc) (struct mob_data *md, int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -39976,6 +41530,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_heal_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_heal_pre[hIndex].func;
 			preHookFunc(md, &heal);
@@ -40002,6 +41557,7 @@ int HP_mob_warpslave_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_warpslave_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -40034,6 +41590,7 @@ int HP_mob_warpslave(struct block_list *bl, int range) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_warpslave_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *range);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_warpslave_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, &range);
@@ -40060,6 +41617,7 @@ int HP_mob_countslave_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_countslave_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -40092,6 +41650,7 @@ int HP_mob_countslave(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_countslave_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_countslave_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -40118,6 +41677,7 @@ int HP_mob_summonslave(struct mob_data *md2, int *value, int amount, uint16 skil
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_summonslave_pre ) {
 		int (*preHookFunc) (struct mob_data *md2, int *value, int *amount, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -40144,6 +41704,7 @@ int HP_mob_getfriendhprate_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_getfriendhprate_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -40176,6 +41737,7 @@ struct block_list* HP_mob_getfriendhprate(struct mob_data *md, int min_rate, int
 	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);
+		*HPMforce_return = false;
 		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);
@@ -40202,6 +41764,7 @@ struct block_list* HP_mob_getmasterhpltmaxrate(struct mob_data *md, int rate) {
 	struct block_list* retVal___ = NULL;
 	if( HPMHooks.count.HP_mob_getmasterhpltmaxrate_pre ) {
 		struct block_list* (*preHookFunc) (struct mob_data *md, int *rate);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getmasterhpltmaxrate_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_getmasterhpltmaxrate_pre[hIndex].func;
 			retVal___ = preHookFunc(md, &rate);
@@ -40228,6 +41791,7 @@ int HP_mob_getfriendstatus_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_getfriendstatus_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -40260,6 +41824,7 @@ struct mob_data* HP_mob_getfriendstatus(struct mob_data *md, int cond1, int cond
 	struct mob_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_mob_getfriendstatus_pre ) {
 		struct mob_data* (*preHookFunc) (struct mob_data *md, int *cond1, int *cond2);
+		*HPMforce_return = false;
 		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);
@@ -40286,6 +41851,7 @@ int HP_mob_skill_use(struct mob_data *md, int64 tick, int event) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_skill_use_pre ) {
 		int (*preHookFunc) (struct mob_data *md, int64 *tick, int *event);
+		*HPMforce_return = false;
 		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);
@@ -40312,6 +41878,7 @@ int HP_mob_skill_event(struct mob_data *md, struct block_list *src, int64 tick,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_skill_event_pre ) {
 		int (*preHookFunc) (struct mob_data *md, struct block_list *src, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -40338,6 +41905,7 @@ int HP_mob_is_clone(int class_) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_is_clone_pre ) {
 		int (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -40364,6 +41932,7 @@ int HP_mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, c
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -40390,6 +41959,7 @@ int HP_mob_clone_delete(struct mob_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_clone_delete_pre ) {
 		int (*preHookFunc) (struct mob_data *md);
+		*HPMforce_return = false;
 		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);
@@ -40416,6 +41986,7 @@ unsigned int HP_mob_drop_adjust(int baserate, int rate_adjust, unsigned short ra
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_drop_adjust_pre ) {
 		unsigned int (*preHookFunc) (int *baserate, int *rate_adjust, unsigned short *rate_min, unsigned short *rate_max);
+		*HPMforce_return = false;
 		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);
@@ -40441,6 +42012,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -40467,6 +42039,7 @@ bool HP_mob_parse_dbrow(char **str) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_parse_dbrow_pre ) {
 		bool (*preHookFunc) (char **str);
+		*HPMforce_return = false;
 		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);
@@ -40493,6 +42066,7 @@ bool HP_mob_readdb_sub(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_readdb_sub_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -40518,6 +42092,7 @@ void HP_mob_readdb(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mob_readdb_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_readdb_pre[hIndex].func;
 			preHookFunc();
@@ -40544,6 +42119,7 @@ int HP_mob_read_sqldb(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_read_sqldb_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_sqldb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_read_sqldb_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -40569,6 +42145,7 @@ void HP_mob_name_constants(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mob_name_constants_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_name_constants_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_name_constants_pre[hIndex].func;
 			preHookFunc();
@@ -40595,6 +42172,7 @@ bool HP_mob_readdb_mobavail(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_readdb_mobavail_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -40621,6 +42199,7 @@ int HP_mob_read_randommonster(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_read_randommonster_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_randommonster_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_read_randommonster_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -40647,6 +42226,7 @@ bool HP_mob_parse_row_chatdb(char **str, const char *source, int line, int *last
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_parse_row_chatdb_pre ) {
 		bool (*preHookFunc) (char **str, const char *source, int *line, int *last_msg_id);
+		*HPMforce_return = false;
 		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);
@@ -40672,6 +42252,7 @@ void HP_mob_readchatdb(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mob_readchatdb_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readchatdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_readchatdb_pre[hIndex].func;
 			preHookFunc();
@@ -40698,6 +42279,7 @@ bool HP_mob_parse_row_mobskilldb(char **str, int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_parse_row_mobskilldb_pre ) {
 		bool (*preHookFunc) (char **str, int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -40723,6 +42305,7 @@ void HP_mob_readskilldb(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mob_readskilldb_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readskilldb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_readskilldb_pre[hIndex].func;
 			preHookFunc();
@@ -40749,6 +42332,7 @@ int HP_mob_read_sqlskilldb(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_mob_read_sqlskilldb_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_sqlskilldb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_read_sqlskilldb_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -40775,6 +42359,7 @@ bool HP_mob_readdb_race2(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_readdb_race2_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -40801,6 +42386,7 @@ bool HP_mob_readdb_itemratio(char *str[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_mob_readdb_itemratio_pre ) {
 		bool (*preHookFunc) (char *str[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -40826,6 +42412,7 @@ void HP_mob_load(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mob_load_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_load_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_load_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -40851,6 +42438,7 @@ void HP_mob_clear_spawninfo(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_mob_clear_spawninfo_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clear_spawninfo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_mob_clear_spawninfo_pre[hIndex].func;
 			preHookFunc();
@@ -40878,6 +42466,7 @@ int HP_npc_init(bool minimal) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_init_pre ) {
 		int (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_init_pre[hIndex].func;
 			retVal___ = preHookFunc(&minimal);
@@ -40904,6 +42493,7 @@ int HP_npc_final(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_final_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_final_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -40930,6 +42520,7 @@ int HP_npc_get_new_npc_id(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_get_new_npc_id_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -40956,6 +42547,7 @@ struct view_data* HP_npc_get_viewdata(int class_) {
 	struct view_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_npc_get_viewdata_pre ) {
 		struct view_data* (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -40982,6 +42574,7 @@ int HP_npc_isnear_sub(struct block_list *bl, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_isnear_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -41014,6 +42607,7 @@ bool HP_npc_isnear(struct block_list *bl) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_npc_isnear_pre ) {
 		bool (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_isnear_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -41040,6 +42634,7 @@ int HP_npc_ontouch_event(struct map_session_data *sd, struct npc_data *nd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_ontouch_event_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		*HPMforce_return = false;
 		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);
@@ -41066,6 +42661,7 @@ int HP_npc_ontouch2_event(struct map_session_data *sd, struct npc_data *nd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_ontouch2_event_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		*HPMforce_return = false;
 		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);
@@ -41092,6 +42688,7 @@ int HP_npc_enable_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_enable_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -41124,6 +42721,7 @@ int HP_npc_enable(const char *name, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_enable_pre ) {
 		int (*preHookFunc) (const char *name, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_enable_pre[hIndex].func;
 			retVal___ = preHookFunc(name, &flag);
@@ -41150,6 +42748,7 @@ struct npc_data* HP_npc_name2id(const char *name) {
 	struct npc_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_npc_name2id_pre ) {
 		struct npc_data* (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_name2id_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_name2id_pre[hIndex].func;
 			retVal___ = preHookFunc(name);
@@ -41176,6 +42775,7 @@ int HP_npc_event_dequeue(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_event_dequeue_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -41203,6 +42803,7 @@ DBData HP_npc_event_export_create(DBKey key, va_list args) {
 	memset(&retVal___, '\0', sizeof(DBData));
 	if( HPMHooks.count.HP_npc_event_export_create_pre ) {
 		DBData (*preHookFunc) (DBKey *key, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -41235,6 +42836,7 @@ int HP_npc_event_export(struct npc_data *nd, int i) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_event_export_pre ) {
 		int (*preHookFunc) (struct npc_data *nd, int *i);
+		*HPMforce_return = false;
 		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);
@@ -41261,6 +42863,7 @@ int HP_npc_event_sub(struct map_session_data *sd, struct event_data *ev, const c
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_event_sub_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct event_data *ev, const char *eventname);
+		*HPMforce_return = false;
 		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);
@@ -41286,6 +42889,7 @@ 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);
+		*HPMforce_return = false;
 		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;
@@ -41318,6 +42922,7 @@ int HP_npc_event_do(const char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_event_do_pre ) {
 		int (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		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);
@@ -41344,6 +42949,7 @@ int HP_npc_event_doall_id(const char *name, int rid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_event_doall_id_pre ) {
 		int (*preHookFunc) (const char *name, int *rid);
+		*HPMforce_return = false;
 		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);
@@ -41370,6 +42976,7 @@ int HP_npc_event_doall(const char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_event_doall_pre ) {
 		int (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		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);
@@ -41396,6 +43003,7 @@ int HP_npc_event_do_clock(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_event_do_clock_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -41421,6 +43029,7 @@ void HP_npc_event_do_oninit(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_event_do_oninit_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -41447,6 +43056,7 @@ int HP_npc_timerevent_export(struct npc_data *nd, int i) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_timerevent_export_pre ) {
 		int (*preHookFunc) (struct npc_data *nd, int *i);
+		*HPMforce_return = false;
 		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);
@@ -41473,6 +43083,7 @@ int HP_npc_timerevent(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_timerevent_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -41499,6 +43110,7 @@ int HP_npc_timerevent_start(struct npc_data *nd, int rid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_timerevent_start_pre ) {
 		int (*preHookFunc) (struct npc_data *nd, int *rid);
+		*HPMforce_return = false;
 		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);
@@ -41525,6 +43137,7 @@ int HP_npc_timerevent_stop(struct npc_data *nd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_timerevent_stop_pre ) {
 		int (*preHookFunc) (struct npc_data *nd);
+		*HPMforce_return = false;
 		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);
@@ -41550,6 +43163,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_quit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_timerevent_quit_pre[hIndex].func;
 			preHookFunc(sd);
@@ -41576,6 +43190,7 @@ int64 HP_npc_gettimerevent_tick(struct npc_data *nd) {
 	int64 retVal___ = 0;
 	if( HPMHooks.count.HP_npc_gettimerevent_tick_pre ) {
 		int64 (*preHookFunc) (struct npc_data *nd);
+		*HPMforce_return = false;
 		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);
@@ -41602,6 +43217,7 @@ int HP_npc_settimerevent_tick(struct npc_data *nd, int newtimer) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_settimerevent_tick_pre ) {
 		int (*preHookFunc) (struct npc_data *nd, int *newtimer);
+		*HPMforce_return = false;
 		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);
@@ -41628,6 +43244,7 @@ int HP_npc_event(struct map_session_data *sd, const char *eventname, int ontouch
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_event_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, const char *eventname, int *ontouch);
+		*HPMforce_return = false;
 		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);
@@ -41654,6 +43271,7 @@ int HP_npc_touch_areanpc_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_touch_areanpc_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -41686,6 +43304,7 @@ int HP_npc_touchnext_areanpc(struct map_session_data *sd, bool leavemap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_touchnext_areanpc_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, bool *leavemap);
+		*HPMforce_return = false;
 		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);
@@ -41712,6 +43331,7 @@ int HP_npc_touch_areanpc(struct map_session_data *sd, int16 m, int16 x, int16 y)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_touch_areanpc_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int16 *m, int16 *x, int16 *y);
+		*HPMforce_return = false;
 		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);
@@ -41738,6 +43358,7 @@ int HP_npc_touch_areanpc2(struct mob_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_touch_areanpc2_pre ) {
 		int (*preHookFunc) (struct mob_data *md);
+		*HPMforce_return = false;
 		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);
@@ -41764,6 +43385,7 @@ int HP_npc_check_areanpc(int flag, int16 m, int16 x, int16 y, int16 range) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_check_areanpc_pre ) {
 		int (*preHookFunc) (int *flag, int16 *m, int16 *x, int16 *y, int16 *range);
+		*HPMforce_return = false;
 		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);
@@ -41790,6 +43412,7 @@ struct npc_data* HP_npc_checknear(struct map_session_data *sd, struct block_list
 	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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_checknear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_checknear_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, bl);
@@ -41816,6 +43439,7 @@ int HP_npc_globalmessage(const char *name, const char *mes) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_globalmessage_pre ) {
 		int (*preHookFunc) (const char *name, const char *mes);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_globalmessage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_globalmessage_pre[hIndex].func;
 			retVal___ = preHookFunc(name, mes);
@@ -41841,6 +43465,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -41867,6 +43492,7 @@ int HP_npc_click(struct map_session_data *sd, struct npc_data *nd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_click_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_click_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_click_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, nd);
@@ -41893,6 +43519,7 @@ int HP_npc_scriptcont(struct map_session_data *sd, int id, bool closing) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_scriptcont_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *id, bool *closing);
+		*HPMforce_return = false;
 		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);
@@ -41919,6 +43546,7 @@ int HP_npc_buysellsel(struct map_session_data *sd, int id, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_buysellsel_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *id, int *type);
+		*HPMforce_return = false;
 		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);
@@ -41945,6 +43573,7 @@ int HP_npc_cashshop_buylist(struct map_session_data *sd, int points, int count,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_cashshop_buylist_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *points, int *count, unsigned short *item_list);
+		*HPMforce_return = false;
 		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);
@@ -41971,6 +43600,7 @@ int HP_npc_buylist_sub(struct map_session_data *sd, int n, unsigned short *item_
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -41997,6 +43627,7 @@ int HP_npc_cashshop_buy(struct map_session_data *sd, int nameid, int amount, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_cashshop_buy_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *amount, int *points);
+		*HPMforce_return = false;
 		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);
@@ -42023,6 +43654,7 @@ int HP_npc_buylist(struct map_session_data *sd, int n, unsigned short *item_list
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_buylist_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n, unsigned short *item_list);
+		*HPMforce_return = false;
 		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);
@@ -42049,6 +43681,7 @@ int HP_npc_selllist_sub(struct map_session_data *sd, int n, unsigned short *item
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42075,6 +43708,7 @@ int HP_npc_selllist(struct map_session_data *sd, int n, unsigned short *item_lis
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_selllist_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n, unsigned short *item_list);
+		*HPMforce_return = false;
 		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);
@@ -42101,6 +43735,7 @@ int HP_npc_remove_map(struct npc_data *nd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_remove_map_pre ) {
 		int (*preHookFunc) (struct npc_data *nd);
+		*HPMforce_return = false;
 		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);
@@ -42127,6 +43762,7 @@ int HP_npc_unload_ev(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_unload_ev_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -42159,6 +43795,7 @@ int HP_npc_unload_ev_label(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_unload_ev_label_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -42191,6 +43828,7 @@ int HP_npc_unload_dup_sub(struct npc_data *nd, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_unload_dup_sub_pre ) {
 		int (*preHookFunc) (struct npc_data *nd, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -42222,6 +43860,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_duplicates_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_unload_duplicates_pre[hIndex].func;
 			preHookFunc(nd);
@@ -42248,6 +43887,7 @@ int HP_npc_unload(struct npc_data *nd, bool single) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_unload_pre ) {
 		int (*preHookFunc) (struct npc_data *nd, bool *single);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_unload_pre[hIndex].func;
 			retVal___ = preHookFunc(nd, &single);
@@ -42273,6 +43913,7 @@ void HP_npc_clearsrcfile(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_clearsrcfile_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_clearsrcfile_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_clearsrcfile_pre[hIndex].func;
 			preHookFunc();
@@ -42298,6 +43939,7 @@ void HP_npc_addsrcfile(const char *name) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_addsrcfile_pre ) {
 		void (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_addsrcfile_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_addsrcfile_pre[hIndex].func;
 			preHookFunc(name);
@@ -42323,6 +43965,7 @@ void HP_npc_delsrcfile(const char *name) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_delsrcfile_pre ) {
 		void (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_delsrcfile_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_delsrcfile_pre[hIndex].func;
 			preHookFunc(name);
@@ -42348,6 +43991,7 @@ void HP_npc_parsename(struct npc_data *nd, const char *name, const char *start,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42374,6 +44018,7 @@ int HP_npc_parseview(const char *w4, const char *start, const char *buffer, cons
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_parseview_pre ) {
 		int (*preHookFunc) (const char *w4, const char *start, const char *buffer, const char *filepath);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parseview_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_parseview_pre[hIndex].func;
 			retVal___ = preHookFunc(w4, start, buffer, filepath);
@@ -42400,6 +44045,7 @@ bool HP_npc_viewisid(const char *viewid) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_npc_viewisid_pre ) {
 		bool (*preHookFunc) (const char *viewid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_viewisid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_viewisid_pre[hIndex].func;
 			retVal___ = preHookFunc(viewid);
@@ -42426,6 +44072,7 @@ struct npc_data* HP_npc_add_warp(char *name, short from_mapid, short from_x, sho
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42452,6 +44099,7 @@ const char* HP_npc_parse_warp(char *w1, char *w2, char *w3, char *w4, const char
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42478,6 +44126,7 @@ const char* HP_npc_parse_shop(char *w1, char *w2, char *w3, char *w4, const char
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42503,6 +44152,7 @@ void HP_npc_convertlabel_db(struct npc_label_list *label_list, const char *filep
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_convertlabel_db_pre ) {
 		void (*preHookFunc) (struct npc_label_list *label_list, const char *filepath);
+		*HPMforce_return = false;
 		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);
@@ -42529,6 +44179,7 @@ const char* HP_npc_skip_script(const char *start, const char *buffer, const char
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_npc_skip_script_pre ) {
 		const char* (*preHookFunc) (const char *start, const char *buffer, const char *filepath);
+		*HPMforce_return = false;
 		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);
@@ -42555,6 +44206,7 @@ const char* HP_npc_parse_script(char *w1, char *w2, char *w3, char *w4, const ch
 	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, int *options);
+		*HPMforce_return = false;
 		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, &options);
@@ -42581,6 +44233,7 @@ const char* HP_npc_parse_duplicate(char *w1, char *w2, char *w3, char *w4, const
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42607,6 +44260,7 @@ int HP_npc_duplicate4instance(struct npc_data *snd, int16 m) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_duplicate4instance_pre ) {
 		int (*preHookFunc) (struct npc_data *snd, int16 *m);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate4instance_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_duplicate4instance_pre[hIndex].func;
 			retVal___ = preHookFunc(snd, &m);
@@ -42632,6 +44286,7 @@ void HP_npc_setcells(struct npc_data *nd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_setcells_pre ) {
 		void (*preHookFunc) (struct npc_data *nd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setcells_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_setcells_pre[hIndex].func;
 			preHookFunc(nd);
@@ -42658,6 +44313,7 @@ int HP_npc_unsetcells_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_unsetcells_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -42689,6 +44345,7 @@ void HP_npc_unsetcells(struct npc_data *nd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_unsetcells_pre ) {
 		void (*preHookFunc) (struct npc_data *nd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_unsetcells_pre[hIndex].func;
 			preHookFunc(nd);
@@ -42714,6 +44371,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_movenpc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_movenpc_pre[hIndex].func;
 			preHookFunc(nd, &x, &y);
@@ -42739,6 +44397,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setdisplayname_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_setdisplayname_pre[hIndex].func;
 			preHookFunc(nd, newname);
@@ -42764,6 +44423,7 @@ 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_);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setclass_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_setclass_pre[hIndex].func;
 			preHookFunc(nd, &class_);
@@ -42790,6 +44450,7 @@ int HP_npc_do_atcmd_event(struct map_session_data *sd, const char *command, cons
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42816,6 +44477,7 @@ const char* HP_npc_parse_function(char *w1, char *w2, char *w3, char *w4, const
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42841,6 +44503,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_parse_mob2_pre[hIndex].func;
 			preHookFunc(mobspawn);
@@ -42867,6 +44530,7 @@ const char* HP_npc_parse_mob(char *w1, char *w2, char *w3, char *w4, const char
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42893,6 +44557,7 @@ const char* HP_npc_parse_mapflag(char *w1, char *w2, char *w3, char *w4, const c
 	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);
+		*HPMforce_return = false;
 		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);
@@ -42919,6 +44584,7 @@ int HP_npc_parsesrcfile(const char *filepath, bool runOnInit) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_parsesrcfile_pre ) {
 		int (*preHookFunc) (const char *filepath, bool *runOnInit);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsesrcfile_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_parsesrcfile_pre[hIndex].func;
 			retVal___ = preHookFunc(filepath, &runOnInit);
@@ -42945,6 +44611,7 @@ int HP_npc_script_event(struct map_session_data *sd, enum npce_event type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_script_event_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, enum npce_event *type);
+		*HPMforce_return = false;
 		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);
@@ -42970,6 +44637,7 @@ void HP_npc_read_event_script(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_read_event_script_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -42996,6 +44664,7 @@ int HP_npc_path_db_clear_sub(DBKey key, DBData *data, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_path_db_clear_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -43028,6 +44697,7 @@ int HP_npc_ev_label_db_clear_sub(DBKey key, DBData *data, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_ev_label_db_clear_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -43060,6 +44730,7 @@ int HP_npc_reload(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_reload_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_reload_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -43086,6 +44757,7 @@ bool HP_npc_unloadfile(const char *filepath) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_npc_unloadfile_pre ) {
 		bool (*preHookFunc) (const char *filepath);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unloadfile_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_unloadfile_pre[hIndex].func;
 			retVal___ = preHookFunc(filepath);
@@ -43111,6 +44783,7 @@ void HP_npc_do_clear_npc(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_do_clear_npc_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -43136,6 +44809,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -43161,6 +44835,7 @@ void HP_npc_debug_warps(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_debug_warps_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_debug_warps_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_debug_warps_pre[hIndex].func;
 			preHookFunc();
@@ -43186,6 +44861,7 @@ void HP_npc_trader_count_funds(struct npc_data *nd, struct map_session_data *sd)
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_trader_count_funds_pre ) {
 		void (*preHookFunc) (struct npc_data *nd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_count_funds_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_trader_count_funds_pre[hIndex].func;
 			preHookFunc(nd, sd);
@@ -43212,6 +44888,7 @@ bool HP_npc_trader_pay(struct npc_data *nd, struct map_session_data *sd, int pri
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_npc_trader_pay_pre ) {
 		bool (*preHookFunc) (struct npc_data *nd, struct map_session_data *sd, int *price, int *points);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_pay_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_trader_pay_pre[hIndex].func;
 			retVal___ = preHookFunc(nd, sd, &price, &points);
@@ -43237,6 +44914,7 @@ void HP_npc_trader_update(int master) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_trader_update_pre ) {
 		void (*preHookFunc) (int *master);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_update_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_trader_update_pre[hIndex].func;
 			preHookFunc(&master);
@@ -43263,6 +44941,7 @@ int HP_npc_market_buylist(struct map_session_data *sd, unsigned short list_size,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_market_buylist_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, unsigned short *list_size, struct packet_npc_market_purchase *p);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_buylist_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_market_buylist_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &list_size, p);
@@ -43289,6 +44968,7 @@ bool HP_npc_trader_open(struct map_session_data *sd, struct npc_data *nd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_npc_trader_open_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, struct npc_data *nd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_open_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_trader_open_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, nd);
@@ -43314,6 +44994,7 @@ void HP_npc_market_fromsql(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_market_fromsql_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_fromsql_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_market_fromsql_pre[hIndex].func;
 			preHookFunc();
@@ -43339,6 +45020,7 @@ void HP_npc_market_tosql(struct npc_data *nd, unsigned short index) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_market_tosql_pre ) {
 		void (*preHookFunc) (struct npc_data *nd, unsigned short *index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_tosql_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_market_tosql_pre[hIndex].func;
 			preHookFunc(nd, &index);
@@ -43364,6 +45046,7 @@ void HP_npc_market_delfromsql(struct npc_data *nd, unsigned short index) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_market_delfromsql_pre ) {
 		void (*preHookFunc) (struct npc_data *nd, unsigned short *index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_delfromsql_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_market_delfromsql_pre[hIndex].func;
 			preHookFunc(nd, &index);
@@ -43389,6 +45072,7 @@ void HP_npc_market_delfromsql_sub(const char *npcname, unsigned short index) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_npc_market_delfromsql_sub_pre ) {
 		void (*preHookFunc) (const char *npcname, unsigned short *index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_delfromsql_sub_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_market_delfromsql_sub_pre[hIndex].func;
 			preHookFunc(npcname, &index);
@@ -43415,6 +45099,7 @@ int HP_npc_secure_timeout_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_npc_secure_timeout_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_secure_timeout_timer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_npc_secure_timeout_timer_pre[hIndex].func;
 			retVal___ = preHookFunc(&tid, &tick, &id, &data);
@@ -43441,6 +45126,7 @@ void HP_party_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_party_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -43466,6 +45152,7 @@ void HP_party_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_party_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_final_pre[hIndex].func;
 			preHookFunc();
@@ -43492,6 +45179,7 @@ struct party_data* HP_party_search(int party_id) {
 	struct party_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_party_search_pre ) {
 		struct party_data* (*preHookFunc) (int *party_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_search_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_search_pre[hIndex].func;
 			retVal___ = preHookFunc(&party_id);
@@ -43518,6 +45206,7 @@ struct party_data* HP_party_searchname(const char *str) {
 	struct party_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_party_searchname_pre ) {
 		struct party_data* (*preHookFunc) (const char *str);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_searchname_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_searchname_pre[hIndex].func;
 			retVal___ = preHookFunc(str);
@@ -43544,6 +45233,7 @@ int HP_party_getmemberid(struct party_data *p, struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_getmemberid_pre ) {
 		int (*preHookFunc) (struct party_data *p, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getmemberid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_getmemberid_pre[hIndex].func;
 			retVal___ = preHookFunc(p, sd);
@@ -43570,6 +45260,7 @@ struct map_session_data* HP_party_getavailablesd(struct party_data *p) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_party_getavailablesd_pre ) {
 		struct map_session_data* (*preHookFunc) (struct party_data *p);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getavailablesd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_getavailablesd_pre[hIndex].func;
 			retVal___ = preHookFunc(p);
@@ -43596,6 +45287,7 @@ int HP_party_create(struct map_session_data *sd, char *name, int item, int item2
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_create_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, char *name, int *item, int *item2);
+		*HPMforce_return = false;
 		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);
@@ -43621,6 +45313,7 @@ void HP_party_created(int account_id, int char_id, int fail, int party_id, char
 	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);
+		*HPMforce_return = false;
 		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);
@@ -43647,6 +45340,7 @@ int HP_party_request_info(int party_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_request_info_pre ) {
 		int (*preHookFunc) (int *party_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -43673,6 +45367,7 @@ int HP_party_invite(struct map_session_data *sd, struct map_session_data *tsd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_invite_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_invite_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_invite_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, tsd);
@@ -43698,6 +45393,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_joined_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_member_joined_pre[hIndex].func;
 			preHookFunc(sd);
@@ -43724,6 +45420,7 @@ int HP_party_member_added(int party_id, int account_id, int char_id, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_member_added_pre ) {
 		int (*preHookFunc) (int *party_id, int *account_id, int *char_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -43750,6 +45447,7 @@ int HP_party_leave(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_leave_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_leave_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_leave_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -43776,6 +45474,7 @@ int HP_party_removemember(struct map_session_data *sd, int account_id, char *nam
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_removemember_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *account_id, char *name);
+		*HPMforce_return = false;
 		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);
@@ -43802,6 +45501,7 @@ int HP_party_member_withdraw(int party_id, int account_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_member_withdraw_pre ) {
 		int (*preHookFunc) (int *party_id, int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -43827,6 +45527,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -43853,6 +45554,7 @@ int HP_party_recv_noinfo(int party_id, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_recv_noinfo_pre ) {
 		int (*preHookFunc) (int *party_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -43879,6 +45581,7 @@ int HP_party_recv_info(struct party *sp, int char_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_recv_info_pre ) {
 		int (*preHookFunc) (struct party *sp, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -43905,6 +45608,7 @@ int HP_party_recv_movemap(int party_id, int account_id, int char_id, unsigned sh
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -43931,6 +45635,7 @@ int HP_party_broken(int party_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_broken_pre ) {
 		int (*preHookFunc) (int *party_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_broken_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_broken_pre[hIndex].func;
 			retVal___ = preHookFunc(&party_id);
@@ -43957,6 +45662,7 @@ int HP_party_optionchanged(int party_id, int account_id, int exp, int item, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_optionchanged_pre ) {
 		int (*preHookFunc) (int *party_id, int *account_id, int *exp, int *item, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -43983,6 +45689,7 @@ int HP_party_changeoption(struct map_session_data *sd, int exp, int item) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_changeoption_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *exp, int *item);
+		*HPMforce_return = false;
 		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);
@@ -44009,6 +45716,7 @@ bool HP_party_changeleader(struct map_session_data *sd, struct map_session_data
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_party_changeleader_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, struct map_session_data *t_sd);
+		*HPMforce_return = false;
 		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);
@@ -44034,6 +45742,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_movemap_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_send_movemap_pre[hIndex].func;
 			preHookFunc(sd);
@@ -44059,6 +45768,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_levelup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_send_levelup_pre[hIndex].func;
 			preHookFunc(sd);
@@ -44085,6 +45795,7 @@ int HP_party_send_logout(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_send_logout_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -44111,6 +45822,7 @@ int HP_party_send_message(struct map_session_data *sd, const char *mes, int len)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_send_message_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, const char *mes, int *len);
+		*HPMforce_return = false;
 		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);
@@ -44137,6 +45849,7 @@ int HP_party_recv_message(int party_id, int account_id, const char *mes, int len
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_recv_message_pre ) {
 		int (*preHookFunc) (int *party_id, int *account_id, const char *mes, int *len);
+		*HPMforce_return = false;
 		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);
@@ -44163,6 +45876,7 @@ int HP_party_skill_check(struct map_session_data *sd, int party_id, uint16 skill
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_skill_check_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *party_id, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -44189,6 +45903,7 @@ int HP_party_send_xy_clear(struct party_data *p) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_send_xy_clear_pre ) {
 		int (*preHookFunc) (struct party_data *p);
+		*HPMforce_return = false;
 		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);
@@ -44215,6 +45930,7 @@ int HP_party_exp_share(struct party_data *p, struct block_list *src, unsigned in
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -44241,6 +45957,7 @@ int HP_party_share_loot(struct party_data *p, struct map_session_data *sd, struc
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -44267,6 +45984,7 @@ int HP_party_send_dot_remove(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_send_dot_remove_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -44293,6 +46011,7 @@ int HP_party_sub_count(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_sub_count_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -44325,6 +46044,7 @@ int HP_party_sub_count_chorus(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_sub_count_chorus_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sub_count_chorus_pre; hIndex++ ) {
 			va_list ap___copy; va_copy(ap___copy, ap);
 			preHookFunc = HPMHooks.list.HP_party_sub_count_chorus_pre[hIndex].func;
@@ -44356,6 +46076,7 @@ void HP_party_booking_register(struct map_session_data *sd, short level, short m
 	int hIndex = 0;
 	if( HPMHooks.count.HP_party_booking_register_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, short *level, short *mapid, short *job);
+		*HPMforce_return = false;
 		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, &mapid, job);
@@ -44381,6 +46102,7 @@ void HP_party_booking_update(struct map_session_data *sd, short *job) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_party_booking_update_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, short *job);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_update_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_booking_update_pre[hIndex].func;
 			preHookFunc(sd, job);
@@ -44406,6 +46128,7 @@ void HP_party_booking_search(struct map_session_data *sd, short level, short map
 	int hIndex = 0;
 	if( HPMHooks.count.HP_party_booking_search_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, short *level, short *mapid, short *job, unsigned long *lastindex, short *resultcount);
+		*HPMforce_return = false;
 		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, &job, &lastindex, &resultcount);
@@ -44431,6 +46154,7 @@ void HP_party_recruit_register(struct map_session_data *sd, short level, const c
 	int hIndex = 0;
 	if( HPMHooks.count.HP_party_recruit_register_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, short *level, const char *notice);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_register_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_recruit_register_pre[hIndex].func;
 			preHookFunc(sd, &level, notice);
@@ -44456,6 +46180,7 @@ void HP_party_recruit_update(struct map_session_data *sd, const char *notice) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_party_recruit_update_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, const char *notice);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_update_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_recruit_update_pre[hIndex].func;
 			preHookFunc(sd, notice);
@@ -44481,6 +46206,7 @@ void HP_party_recruit_search(struct map_session_data *sd, short level, short map
 	int hIndex = 0;
 	if( HPMHooks.count.HP_party_recruit_search_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, short *level, short *mapid, unsigned long *lastindex, short *resultcount);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_search_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_recruit_search_pre[hIndex].func;
 			preHookFunc(sd, &level, &mapid, &lastindex, &resultcount);
@@ -44507,6 +46233,7 @@ bool HP_party_booking_delete(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_party_booking_delete_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -44533,6 +46260,7 @@ int HP_party_vforeachsamemap(int ( *func ) (struct block_list *, va_list), struc
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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;
@@ -44565,6 +46293,7 @@ int HP_party_send_xy_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_send_xy_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -44590,6 +46319,7 @@ void HP_party_fill_member(struct party_member *member, struct map_session_data *
 	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);
+		*HPMforce_return = false;
 		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);
@@ -44616,6 +46346,7 @@ TBL_PC* HP_party_sd_check(int party_id, int account_id, int char_id) {
 	TBL_PC* retVal___ = NULL;
 	if( HPMHooks.count.HP_party_sd_check_pre ) {
 		TBL_PC* (*preHookFunc) (int *party_id, int *account_id, int *char_id);
+		*HPMforce_return = false;
 		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);
@@ -44641,6 +46372,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_check_state_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_party_check_state_pre[hIndex].func;
 			preHookFunc(p);
@@ -44667,6 +46399,7 @@ struct party_booking_ad_info* HP_party_create_booking_data(void) {
 	struct party_booking_ad_info* retVal___ = NULL;
 	if( HPMHooks.count.HP_party_create_booking_data_pre ) {
 		struct party_booking_ad_info* (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -44693,6 +46426,7 @@ int HP_party_db_final(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_party_db_final_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -44726,6 +46460,7 @@ int HP_path_blownpos(int16 m, int16 x0, int16 y0, int16 dx, int16 dy, int count)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_path_blownpos_pre ) {
 		int (*preHookFunc) (int16 *m, int16 *x0, int16 *y0, int16 *dx, int16 *dy, int *count);
+		*HPMforce_return = false;
 		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);
@@ -44752,6 +46487,7 @@ bool HP_path_search(struct walkpath_data *wpd, int16 m, int16 x0, int16 y0, int1
 	bool retVal___ = false;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -44778,6 +46514,7 @@ bool HP_path_search_long(struct shootpath_data *spd, int16 m, int16 x0, int16 y0
 	bool retVal___ = false;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -44804,6 +46541,7 @@ int HP_path_check_distance(int dx, int dy, int distance) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_path_check_distance_pre ) {
 		int (*preHookFunc) (int *dx, int *dy, int *distance);
+		*HPMforce_return = false;
 		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);
@@ -44830,6 +46568,7 @@ unsigned int HP_path_distance(int dx, int dy) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_path_distance_pre ) {
 		unsigned int (*preHookFunc) (int *dx, int *dy);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_distance_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_path_distance_pre[hIndex].func;
 			retVal___ = preHookFunc(&dx, &dy);
@@ -44856,6 +46595,7 @@ void HP_pcg_init(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pcg_init_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_init_pre[hIndex].func;
 			preHookFunc();
@@ -44881,6 +46621,7 @@ void HP_pcg_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pcg_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_final_pre[hIndex].func;
 			preHookFunc();
@@ -44906,6 +46647,7 @@ void HP_pcg_reload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pcg_reload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_reload_pre[hIndex].func;
 			preHookFunc();
@@ -44932,6 +46674,7 @@ GroupSettings* HP_pcg_get_dummy_group(void) {
 	GroupSettings* retVal___ = NULL;
 	if( HPMHooks.count.HP_pcg_get_dummy_group_pre ) {
 		GroupSettings* (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_dummy_group_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_get_dummy_group_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -44958,6 +46701,7 @@ bool HP_pcg_exists(int group_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pcg_exists_pre ) {
 		bool (*preHookFunc) (int *group_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_exists_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_exists_pre[hIndex].func;
 			retVal___ = preHookFunc(&group_id);
@@ -44984,6 +46728,7 @@ GroupSettings* HP_pcg_id2group(int group_id) {
 	GroupSettings* retVal___ = NULL;
 	if( HPMHooks.count.HP_pcg_id2group_pre ) {
 		GroupSettings* (*preHookFunc) (int *group_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_id2group_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_id2group_pre[hIndex].func;
 			retVal___ = preHookFunc(&group_id);
@@ -45010,6 +46755,7 @@ bool HP_pcg_has_permission(GroupSettings *group, unsigned int permission) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pcg_has_permission_pre ) {
 		bool (*preHookFunc) (GroupSettings *group, unsigned int *permission);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_has_permission_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_has_permission_pre[hIndex].func;
 			retVal___ = preHookFunc(group, &permission);
@@ -45036,6 +46782,7 @@ bool HP_pcg_should_log_commands(GroupSettings *group) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pcg_should_log_commands_pre ) {
 		bool (*preHookFunc) (GroupSettings *group);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_should_log_commands_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_should_log_commands_pre[hIndex].func;
 			retVal___ = preHookFunc(group);
@@ -45062,6 +46809,7 @@ const char* HP_pcg_get_name(GroupSettings *group) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_pcg_get_name_pre ) {
 		const char* (*preHookFunc) (GroupSettings *group);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_name_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_get_name_pre[hIndex].func;
 			retVal___ = preHookFunc(group);
@@ -45088,6 +46836,7 @@ int HP_pcg_get_level(GroupSettings *group) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pcg_get_level_pre ) {
 		int (*preHookFunc) (GroupSettings *group);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_level_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_get_level_pre[hIndex].func;
 			retVal___ = preHookFunc(group);
@@ -45114,6 +46863,7 @@ int HP_pcg_get_idx(GroupSettings *group) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pcg_get_idx_pre ) {
 		int (*preHookFunc) (GroupSettings *group);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_idx_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pcg_get_idx_pre[hIndex].func;
 			retVal___ = preHookFunc(group);
@@ -45140,6 +46890,7 @@ void HP_pc_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -45165,6 +46916,7 @@ void HP_pc_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_final_pre[hIndex].func;
 			preHookFunc();
@@ -45191,6 +46943,7 @@ struct map_session_data* HP_pc_get_dummy_sd(void) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_pc_get_dummy_sd_pre ) {
 		struct map_session_data* (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -45217,6 +46970,7 @@ int HP_pc_class2idx(int class_) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_class2idx_pre ) {
 		int (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_class2idx_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_class2idx_pre[hIndex].func;
 			retVal___ = preHookFunc(&class_);
@@ -45243,6 +46997,7 @@ bool HP_pc_can_give_items(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pc_can_give_items_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -45269,6 +47024,7 @@ bool HP_pc_can_give_bound_items(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pc_can_give_bound_items_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_give_bound_items_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_can_give_bound_items_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -45295,6 +47051,7 @@ bool HP_pc_can_use_command(struct map_session_data *sd, const char *command) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pc_can_use_command_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const char *command);
+		*HPMforce_return = false;
 		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);
@@ -45321,6 +47078,7 @@ int HP_pc_set_group(struct map_session_data *sd, int group_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_set_group_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *group_id);
+		*HPMforce_return = false;
 		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);
@@ -45347,6 +47105,7 @@ bool HP_pc_should_log_commands(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pc_should_log_commands_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -45373,6 +47132,7 @@ int HP_pc_setrestartvalue(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setrestartvalue_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setrestartvalue_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setrestartvalue_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -45399,6 +47159,7 @@ int HP_pc_makesavestatus(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_makesavestatus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_makesavestatus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_makesavestatus_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -45424,6 +47185,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_respawn_pre[hIndex].func;
 			preHookFunc(sd, &clrtype);
@@ -45450,6 +47212,7 @@ int HP_pc_setnewpc(struct map_session_data *sd, int account_id, int char_id, int
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -45476,6 +47239,7 @@ bool HP_pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_
 	bool retVal___ = false;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -45501,6 +47265,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authfail_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_authfail_pre[hIndex].func;
 			preHookFunc(sd);
@@ -45527,6 +47292,7 @@ int HP_pc_reg_received(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_reg_received_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -45553,6 +47319,7 @@ int HP_pc_isequip(struct map_session_data *sd, int n) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_isequip_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_isequip_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &n);
@@ -45579,6 +47346,7 @@ int HP_pc_equippoint(struct map_session_data *sd, int n) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_equippoint_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equippoint_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_equippoint_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &n);
@@ -45605,6 +47373,7 @@ int HP_pc_setinventorydata(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setinventorydata_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinventorydata_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setinventorydata_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -45631,6 +47400,7 @@ int HP_pc_checkskill(struct map_session_data *sd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkskill_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -45657,6 +47427,7 @@ int HP_pc_checkskill2(struct map_session_data *sd, uint16 index) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkskill2_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_checkskill2_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &index);
@@ -45683,6 +47454,7 @@ int HP_pc_checkallowskill(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkallowskill_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkallowskill_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_checkallowskill_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -45709,6 +47481,7 @@ int HP_pc_checkequip(struct map_session_data *sd, int pos) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkequip_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *pos);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkequip_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_checkequip_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &pos);
@@ -45735,6 +47508,7 @@ int HP_pc_calc_skilltree(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_calc_skilltree_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -45761,6 +47535,7 @@ int HP_pc_calc_skilltree_normalize_job(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_calc_skilltree_normalize_job_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -45787,6 +47562,7 @@ int HP_pc_clean_skilltree(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_clean_skilltree_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -45813,6 +47589,7 @@ int HP_pc_setpos(struct map_session_data *sd, unsigned short map_index, int x, i
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setpos_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, unsigned short *map_index, int *x, int *y, clr_type *clrtype);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setpos_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setpos_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &map_index, &x, &y, &clrtype);
@@ -45839,6 +47616,7 @@ int HP_pc_setsavepoint(struct map_session_data *sd, short map_index, int x, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setsavepoint_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, short *map_index, int *x, int *y);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setsavepoint_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setsavepoint_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &map_index, &x, &y);
@@ -45865,6 +47643,7 @@ int HP_pc_randomwarp(struct map_session_data *sd, clr_type type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_randomwarp_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, clr_type *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_randomwarp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_randomwarp_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -45891,6 +47670,7 @@ int HP_pc_memo(struct map_session_data *sd, int pos) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_memo_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *pos);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_memo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_memo_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &pos);
@@ -45917,6 +47697,7 @@ int HP_pc_checkadditem(struct map_session_data *sd, int nameid, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkadditem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -45943,6 +47724,7 @@ int HP_pc_inventoryblank(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_inventoryblank_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventoryblank_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_inventoryblank_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -45969,6 +47751,7 @@ int HP_pc_search_inventory(struct map_session_data *sd, int item_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_search_inventory_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *item_id);
+		*HPMforce_return = false;
 		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);
@@ -45995,6 +47778,7 @@ int HP_pc_payzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type ty
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46021,6 +47805,7 @@ int HP_pc_additem(struct map_session_data *sd, struct item *item_data, int amoun
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46047,6 +47832,7 @@ int HP_pc_getzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type ty
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46073,6 +47859,7 @@ int HP_pc_delitem(struct map_session_data *sd, int n, int amount, int type, shor
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46099,6 +47886,7 @@ int HP_pc_paycash(struct map_session_data *sd, int price, int points) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_paycash_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *price, int *points);
+		*HPMforce_return = false;
 		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);
@@ -46125,6 +47913,7 @@ int HP_pc_getcash(struct map_session_data *sd, int cash, int points) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_getcash_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *cash, int *points);
+		*HPMforce_return = false;
 		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);
@@ -46151,6 +47940,7 @@ int HP_pc_cart_additem(struct map_session_data *sd, struct item *item_data, int
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46177,6 +47967,7 @@ int HP_pc_cart_delitem(struct map_session_data *sd, int n, int amount, int type,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46203,6 +47994,7 @@ int HP_pc_putitemtocart(struct map_session_data *sd, int idx, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_putitemtocart_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -46229,6 +48021,7 @@ int HP_pc_getitemfromcart(struct map_session_data *sd, int idx, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_getitemfromcart_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -46255,6 +48048,7 @@ int HP_pc_cartitem_amount(struct map_session_data *sd, int idx, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_cartitem_amount_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *idx, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -46281,6 +48075,7 @@ int HP_pc_takeitem(struct map_session_data *sd, struct flooritem_data *fitem) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_takeitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct flooritem_data *fitem);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_takeitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_takeitem_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, fitem);
@@ -46307,6 +48102,7 @@ int HP_pc_dropitem(struct map_session_data *sd, int n, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_dropitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -46333,6 +48129,7 @@ bool HP_pc_isequipped(struct map_session_data *sd, int nameid) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pc_isequipped_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequipped_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_isequipped_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &nameid);
@@ -46359,6 +48156,7 @@ bool HP_pc_can_Adopt(struct map_session_data *p1_sd, struct map_session_data *p2
 	bool retVal___ = false;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46385,6 +48183,7 @@ bool HP_pc_adoption(struct map_session_data *p1_sd, struct map_session_data *p2_
 	bool retVal___ = false;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46411,6 +48210,7 @@ int HP_pc_updateweightstatus(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_updateweightstatus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_updateweightstatus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_updateweightstatus_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -46437,6 +48237,7 @@ int HP_pc_addautobonus(struct s_autobonus *bonus, char max, const char *bonus_sc
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46463,6 +48264,7 @@ int HP_pc_exeautobonus(struct map_session_data *sd, struct s_autobonus *bonus) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_exeautobonus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct s_autobonus *bonus);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_exeautobonus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_exeautobonus_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, bonus);
@@ -46489,6 +48291,7 @@ int HP_pc_endautobonus(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_endautobonus_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -46515,6 +48318,7 @@ int HP_pc_delautobonus(struct map_session_data *sd, struct s_autobonus *bonus, c
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_delautobonus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct s_autobonus *bonus, char *max, bool *restore);
+		*HPMforce_return = false;
 		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);
@@ -46541,6 +48345,7 @@ int HP_pc_bonus(struct map_session_data *sd, int type, int val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_bonus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		*HPMforce_return = false;
 		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);
@@ -46567,6 +48372,7 @@ int HP_pc_bonus2(struct map_session_data *sd, int type, int type2, int val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_bonus2_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *val);
+		*HPMforce_return = false;
 		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);
@@ -46593,6 +48399,7 @@ int HP_pc_bonus3(struct map_session_data *sd, int type, int type2, int type3, in
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_bonus3_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *type3, int *val);
+		*HPMforce_return = false;
 		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);
@@ -46619,6 +48426,7 @@ int HP_pc_bonus4(struct map_session_data *sd, int type, int type2, int type3, in
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_bonus4_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *type2, int *type3, int *type4, int *val);
+		*HPMforce_return = false;
 		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);
@@ -46645,6 +48453,7 @@ int HP_pc_bonus5(struct map_session_data *sd, int type, int type2, int type3, in
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -46671,6 +48480,7 @@ int HP_pc_skill(struct map_session_data *sd, int id, int level, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_skill_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *id, int *level, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -46697,6 +48507,7 @@ int HP_pc_insert_card(struct map_session_data *sd, int idx_card, int idx_equip)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_insert_card_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *idx_card, int *idx_equip);
+		*HPMforce_return = false;
 		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);
@@ -46723,6 +48534,7 @@ int HP_pc_steal_item(struct map_session_data *sd, struct block_list *bl, uint16
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_steal_item_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -46749,6 +48561,7 @@ int HP_pc_steal_coin(struct map_session_data *sd, struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_steal_coin_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -46775,6 +48588,7 @@ int HP_pc_modifybuyvalue(struct map_session_data *sd, int orig_value) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_modifybuyvalue_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *orig_value);
+		*HPMforce_return = false;
 		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);
@@ -46801,6 +48615,7 @@ int HP_pc_modifysellvalue(struct map_session_data *sd, int orig_value) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_modifysellvalue_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *orig_value);
+		*HPMforce_return = false;
 		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);
@@ -46827,6 +48642,7 @@ int HP_pc_follow(struct map_session_data *sd, int target_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_follow_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *target_id);
+		*HPMforce_return = false;
 		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);
@@ -46853,6 +48669,7 @@ int HP_pc_stop_following(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_stop_following_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -46879,6 +48696,7 @@ unsigned int HP_pc_maxbaselv(struct map_session_data *sd) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_maxbaselv_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxbaselv_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_maxbaselv_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -46905,6 +48723,7 @@ unsigned int HP_pc_maxjoblv(struct map_session_data *sd) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_maxjoblv_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxjoblv_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_maxjoblv_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -46931,6 +48750,7 @@ int HP_pc_checkbaselevelup(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkbaselevelup_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkbaselevelup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_checkbaselevelup_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -46957,6 +48777,7 @@ int HP_pc_checkjoblevelup(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkjoblevelup_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkjoblevelup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_checkjoblevelup_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -46983,6 +48804,7 @@ int HP_pc_gainexp(struct map_session_data *sd, struct block_list *src, unsigned
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -47009,6 +48831,7 @@ unsigned int HP_pc_nextbaseexp(struct map_session_data *sd) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_nextbaseexp_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextbaseexp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_nextbaseexp_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47035,6 +48858,7 @@ unsigned int HP_pc_thisbaseexp(struct map_session_data *sd) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_thisbaseexp_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisbaseexp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_thisbaseexp_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47061,6 +48885,7 @@ unsigned int HP_pc_nextjobexp(struct map_session_data *sd) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_nextjobexp_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextjobexp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_nextjobexp_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47087,6 +48912,7 @@ unsigned int HP_pc_thisjobexp(struct map_session_data *sd) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_thisjobexp_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisjobexp_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_thisjobexp_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47113,6 +48939,7 @@ int HP_pc_gets_status_point(int level) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_gets_status_point_pre ) {
 		int (*preHookFunc) (int *level);
+		*HPMforce_return = false;
 		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);
@@ -47139,6 +48966,7 @@ int HP_pc_need_status_point(struct map_session_data *sd, int type, int val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_need_status_point_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		*HPMforce_return = false;
 		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);
@@ -47165,6 +48993,7 @@ int HP_pc_maxparameterincrease(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_maxparameterincrease_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxparameterincrease_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_maxparameterincrease_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -47191,6 +49020,7 @@ bool HP_pc_statusup(struct map_session_data *sd, int type, int increase) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pc_statusup_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, int *type, int *increase);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_statusup_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type, &increase);
@@ -47217,6 +49047,7 @@ int HP_pc_statusup2(struct map_session_data *sd, int type, int val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_statusup2_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		*HPMforce_return = false;
 		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);
@@ -47243,6 +49074,7 @@ int HP_pc_skillup(struct map_session_data *sd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_skillup_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -47269,6 +49101,7 @@ int HP_pc_allskillup(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_allskillup_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_allskillup_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_allskillup_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47295,6 +49128,7 @@ int HP_pc_resetlvl(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_resetlvl_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetlvl_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_resetlvl_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -47321,6 +49155,7 @@ int HP_pc_resetstate(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_resetstate_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetstate_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_resetstate_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47347,6 +49182,7 @@ int HP_pc_resetskill(struct map_session_data *sd, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_resetskill_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetskill_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_resetskill_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &flag);
@@ -47373,6 +49209,7 @@ int HP_pc_resetfeel(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_resetfeel_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetfeel_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_resetfeel_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47399,6 +49236,7 @@ int HP_pc_resethate(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_resethate_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resethate_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_resethate_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47425,6 +49263,7 @@ int HP_pc_equipitem(struct map_session_data *sd, int n, int req_pos) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_equipitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n, int *req_pos);
+		*HPMforce_return = false;
 		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);
@@ -47451,6 +49290,7 @@ int HP_pc_unequipitem(struct map_session_data *sd, int n, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_unequipitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -47477,6 +49317,7 @@ int HP_pc_checkitem(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_checkitem_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47503,6 +49344,7 @@ int HP_pc_useitem(struct map_session_data *sd, int n) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_useitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_useitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_useitem_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &n);
@@ -47529,6 +49371,7 @@ int HP_pc_skillatk_bonus(struct map_session_data *sd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_skillatk_bonus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -47555,6 +49398,7 @@ int HP_pc_skillheal_bonus(struct map_session_data *sd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_skillheal_bonus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -47581,6 +49425,7 @@ int HP_pc_skillheal2_bonus(struct map_session_data *sd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_skillheal2_bonus_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -47606,6 +49451,7 @@ void HP_pc_damage(struct map_session_data *sd, struct block_list *src, unsigned
 	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);
+		*HPMforce_return = false;
 		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);
@@ -47632,6 +49478,7 @@ int HP_pc_dead(struct map_session_data *sd, struct block_list *src) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_dead_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct block_list *src);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dead_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_dead_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, src);
@@ -47657,6 +49504,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_revive_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_revive_pre[hIndex].func;
 			preHookFunc(sd, &hp, &sp);
@@ -47682,6 +49530,7 @@ void HP_pc_heal(struct map_session_data *sd, unsigned int hp, unsigned int sp, i
 	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);
+		*HPMforce_return = false;
 		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);
@@ -47708,6 +49557,7 @@ int HP_pc_itemheal(struct map_session_data *sd, int itemid, int hp, int sp) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_itemheal_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *itemid, int *hp, int *sp);
+		*HPMforce_return = false;
 		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);
@@ -47734,6 +49584,7 @@ int HP_pc_percentheal(struct map_session_data *sd, int hp, int sp) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_percentheal_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *hp, int *sp);
+		*HPMforce_return = false;
 		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);
@@ -47760,6 +49611,7 @@ int HP_pc_jobchange(struct map_session_data *sd, int job, int upper) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_jobchange_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *job, int *upper);
+		*HPMforce_return = false;
 		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);
@@ -47786,6 +49638,7 @@ int HP_pc_setoption(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setoption_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setoption_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setoption_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -47812,6 +49665,7 @@ int HP_pc_setcart(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setcart_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setcart_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setcart_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -47838,6 +49692,7 @@ int HP_pc_setfalcon(struct map_session_data *sd, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setfalcon_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setfalcon_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setfalcon_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &flag);
@@ -47864,6 +49719,7 @@ int HP_pc_setriding(struct map_session_data *sd, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setriding_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setriding_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setriding_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &flag);
@@ -47890,6 +49746,7 @@ int HP_pc_setmadogear(struct map_session_data *sd, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setmadogear_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setmadogear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setmadogear_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &flag);
@@ -47916,6 +49773,7 @@ int HP_pc_changelook(struct map_session_data *sd, int type, int val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_changelook_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		*HPMforce_return = false;
 		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);
@@ -47942,6 +49800,7 @@ int HP_pc_equiplookall(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_equiplookall_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equiplookall_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_equiplookall_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -47968,6 +49827,7 @@ int HP_pc_readparam(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_readparam_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readparam_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_readparam_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -47994,6 +49854,7 @@ int HP_pc_setparam(struct map_session_data *sd, int type, int val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setparam_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		*HPMforce_return = false;
 		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);
@@ -48020,6 +49881,7 @@ int HP_pc_readreg(struct map_session_data *sd, int64 reg) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_readreg_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int64 *reg);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readreg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_readreg_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &reg);
@@ -48045,6 +49907,7 @@ void HP_pc_setreg(struct map_session_data *sd, int64 reg, int val) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_setreg_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int64 *reg, int *val);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setreg_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setreg_pre[hIndex].func;
 			preHookFunc(sd, &reg, &val);
@@ -48071,6 +49934,7 @@ char* HP_pc_readregstr(struct map_session_data *sd, int64 reg) {
 	char* retVal___ = NULL;
 	if( HPMHooks.count.HP_pc_readregstr_pre ) {
 		char* (*preHookFunc) (struct map_session_data *sd, int64 *reg);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregstr_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_readregstr_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &reg);
@@ -48096,6 +49960,7 @@ void HP_pc_setregstr(struct map_session_data *sd, int64 reg, const char *str) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_setregstr_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int64 *reg, const char *str);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregstr_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setregstr_pre[hIndex].func;
 			preHookFunc(sd, &reg, str);
@@ -48122,6 +49987,7 @@ int HP_pc_readregistry(struct map_session_data *sd, int64 reg) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_readregistry_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int64 *reg);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_readregistry_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &reg);
@@ -48148,6 +50014,7 @@ int HP_pc_setregistry(struct map_session_data *sd, int64 reg, int val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setregistry_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int64 *reg, int *val);
+		*HPMforce_return = false;
 		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);
@@ -48174,6 +50041,7 @@ char* HP_pc_readregistry_str(struct map_session_data *sd, int64 reg) {
 	char* retVal___ = NULL;
 	if( HPMHooks.count.HP_pc_readregistry_str_pre ) {
 		char* (*preHookFunc) (struct map_session_data *sd, int64 *reg);
+		*HPMforce_return = false;
 		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);
@@ -48200,6 +50068,7 @@ int HP_pc_setregistry_str(struct map_session_data *sd, int64 reg, const char *va
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setregistry_str_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int64 *reg, const char *val);
+		*HPMforce_return = false;
 		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);
@@ -48226,6 +50095,7 @@ int HP_pc_addeventtimer(struct map_session_data *sd, int tick, const char *name)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_addeventtimer_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *tick, const char *name);
+		*HPMforce_return = false;
 		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);
@@ -48252,6 +50122,7 @@ int HP_pc_deleventtimer(struct map_session_data *sd, const char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_deleventtimer_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_deleventtimer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_deleventtimer_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, name);
@@ -48278,6 +50149,7 @@ int HP_pc_cleareventtimer(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_cleareventtimer_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cleareventtimer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_cleareventtimer_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -48304,6 +50176,7 @@ int HP_pc_addeventtimercount(struct map_session_data *sd, const char *name, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_addeventtimercount_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, const char *name, int *tick);
+		*HPMforce_return = false;
 		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);
@@ -48330,6 +50203,7 @@ int HP_pc_calc_pvprank(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_calc_pvprank_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -48356,6 +50230,7 @@ int HP_pc_calc_pvprank_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_calc_pvprank_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -48382,6 +50257,7 @@ int HP_pc_ismarried(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_ismarried_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_ismarried_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_ismarried_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -48408,6 +50284,7 @@ int HP_pc_marriage(struct map_session_data *sd, struct map_session_data *dstsd)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_marriage_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_marriage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_marriage_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, dstsd);
@@ -48434,6 +50311,7 @@ int HP_pc_divorce(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_divorce_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_divorce_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_divorce_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -48460,6 +50338,7 @@ struct map_session_data* HP_pc_get_partner(struct map_session_data *sd) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_pc_get_partner_pre ) {
 		struct map_session_data* (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -48486,6 +50365,7 @@ struct map_session_data* HP_pc_get_father(struct map_session_data *sd) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_pc_get_father_pre ) {
 		struct map_session_data* (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -48512,6 +50392,7 @@ struct map_session_data* HP_pc_get_mother(struct map_session_data *sd) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_pc_get_mother_pre ) {
 		struct map_session_data* (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -48538,6 +50419,7 @@ struct map_session_data* HP_pc_get_child(struct map_session_data *sd) {
 	struct map_session_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_pc_get_child_pre ) {
 		struct map_session_data* (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -48563,6 +50445,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bleeding_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_bleeding_pre[hIndex].func;
 			preHookFunc(sd, &diff_tick);
@@ -48588,6 +50471,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_regen_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_regen_pre[hIndex].func;
 			preHookFunc(sd, &diff_tick);
@@ -48613,6 +50497,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstand_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setstand_pre[hIndex].func;
 			preHookFunc(sd);
@@ -48639,6 +50524,7 @@ int HP_pc_candrop(struct map_session_data *sd, struct item *item) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_candrop_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct item *item);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_candrop_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_candrop_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, item);
@@ -48665,6 +50551,7 @@ int HP_pc_jobid2mapid(unsigned short b_class) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_jobid2mapid_pre ) {
 		int (*preHookFunc) (unsigned short *b_class);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobid2mapid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_jobid2mapid_pre[hIndex].func;
 			retVal___ = preHookFunc(&b_class);
@@ -48691,6 +50578,7 @@ int HP_pc_mapid2jobid(unsigned short class_, int sex) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_mapid2jobid_pre ) {
 		int (*preHookFunc) (unsigned short *class_, int *sex);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_mapid2jobid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_mapid2jobid_pre[hIndex].func;
 			retVal___ = preHookFunc(&class_, &sex);
@@ -48717,6 +50605,7 @@ const char* HP_pc_job_name(int class_) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_pc_job_name_pre ) {
 		const char* (*preHookFunc) (int *class_);
+		*HPMforce_return = false;
 		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_);
@@ -48742,6 +50631,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinvincibletimer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_setinvincibletimer_pre[hIndex].func;
 			preHookFunc(sd, &val);
@@ -48767,6 +50657,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delinvincibletimer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_delinvincibletimer_pre[hIndex].func;
 			preHookFunc(sd);
@@ -48793,6 +50684,7 @@ int HP_pc_addspiritball(struct map_session_data *sd, int interval, int max) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_addspiritball_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *interval, int *max);
+		*HPMforce_return = false;
 		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);
@@ -48819,6 +50711,7 @@ int HP_pc_delspiritball(struct map_session_data *sd, int count, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_delspiritball_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *count, int *type);
+		*HPMforce_return = false;
 		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);
@@ -48844,6 +50737,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addfame_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_addfame_pre[hIndex].func;
 			preHookFunc(sd, &count);
@@ -48870,6 +50764,7 @@ unsigned char HP_pc_famerank(int char_id, int job) {
 	unsigned char retVal___ = 0;
 	if( HPMHooks.count.HP_pc_famerank_pre ) {
 		unsigned char (*preHookFunc) (int *char_id, int *job);
+		*HPMforce_return = false;
 		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);
@@ -48896,6 +50791,7 @@ int HP_pc_set_hate_mob(struct map_session_data *sd, int pos, struct block_list *
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_set_hate_mob_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *pos, struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -48922,6 +50818,7 @@ int HP_pc_readdb(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_readdb_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_readdb_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -48948,6 +50845,7 @@ int HP_pc_map_day_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_map_day_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -48974,6 +50872,7 @@ int HP_pc_map_night_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_map_night_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -48999,6 +50898,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rentals_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_inventory_rentals_pre[hIndex].func;
 			preHookFunc(sd);
@@ -49025,6 +50925,7 @@ int HP_pc_inventory_rental_clear(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_inventory_rental_clear_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -49050,6 +50951,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -49076,6 +50978,7 @@ int HP_pc_disguise(struct map_session_data *sd, int class_) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_disguise_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *class_);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_disguise_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_disguise_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &class_);
@@ -49102,6 +51005,7 @@ bool HP_pc_isautolooting(struct map_session_data *sd, int nameid) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pc_isautolooting_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isautolooting_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_isautolooting_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &nameid);
@@ -49127,6 +51031,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_overheat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_overheat_pre[hIndex].func;
 			preHookFunc(sd, &val);
@@ -49153,6 +51058,7 @@ int HP_pc_banding(struct map_session_data *sd, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_banding_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -49178,6 +51084,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -49204,6 +51111,7 @@ int HP_pc_load_combo(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_load_combo_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -49230,6 +51138,7 @@ int HP_pc_add_charm(struct map_session_data *sd, int interval, int max, int type
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_add_charm_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *interval, int *max, int *type);
+		*HPMforce_return = false;
 		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);
@@ -49256,6 +51165,7 @@ int HP_pc_del_charm(struct map_session_data *sd, int count, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_del_charm_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *count, int *type);
+		*HPMforce_return = false;
 		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);
@@ -49281,6 +51191,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_baselevelchanged_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_baselevelchanged_pre[hIndex].func;
 			preHookFunc(sd);
@@ -49307,6 +51218,7 @@ int HP_pc_level_penalty_mod(int diff, unsigned char race, unsigned short mode, i
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_level_penalty_mod_pre ) {
 		int (*preHookFunc) (int *diff, unsigned char *race, unsigned short *mode, int *type);
+		*HPMforce_return = false;
 		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);
@@ -49333,6 +51245,7 @@ int HP_pc_calc_skillpoint(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_calc_skillpoint_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -49359,6 +51272,7 @@ int HP_pc_invincible_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_invincible_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -49385,6 +51299,7 @@ int HP_pc_spiritball_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_spiritball_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -49411,6 +51326,7 @@ int HP_pc_check_banding(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_check_banding_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -49443,6 +51359,7 @@ int HP_pc_inventory_rental_end(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_inventory_rental_end_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -49468,6 +51385,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -49494,6 +51412,7 @@ int HP_pc_bonus_autospell(struct s_autospell *spell, int max, short id, short lv
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -49520,6 +51439,7 @@ int HP_pc_bonus_autospell_onskill(struct s_autospell *spell, int max, short src_
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -49546,6 +51466,7 @@ int HP_pc_bonus_addeff(struct s_addeffect *effect, int max, enum sc_type id, sho
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -49572,6 +51493,7 @@ int HP_pc_bonus_addeff_onskill(struct s_addeffectonskill *effect, int max, enum
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -49598,6 +51520,7 @@ int HP_pc_bonus_item_drop(struct s_add_drop *drop, const short max, short id, sh
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -49623,6 +51546,7 @@ void HP_pc_calcexp(struct map_session_data *sd, unsigned int *base_exp, unsigned
 	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);
+		*HPMforce_return = false;
 		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);
@@ -49649,6 +51573,7 @@ int HP_pc_respawn_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_respawn_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -49675,6 +51600,7 @@ int HP_pc_jobchange_killclone(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_jobchange_killclone_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -49707,6 +51633,7 @@ int HP_pc_getstat(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_getstat_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getstat_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_getstat_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -49733,6 +51660,7 @@ int HP_pc_setstat(struct map_session_data *sd, int type, int val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_setstat_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type, int *val);
+		*HPMforce_return = false;
 		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);
@@ -49759,6 +51687,7 @@ int HP_pc_eventtimer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_eventtimer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -49785,6 +51714,7 @@ int HP_pc_daynight_timer_sub(struct map_session_data *sd, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_daynight_timer_sub_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -49817,6 +51747,7 @@ int HP_pc_charm_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_charm_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -49843,6 +51774,7 @@ bool HP_pc_readdb_levelpenalty(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pc_readdb_levelpenalty_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -49869,6 +51801,7 @@ int HP_pc_autosave(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_autosave_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -49895,6 +51828,7 @@ int HP_pc_follow_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_follow_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -49920,6 +51854,7 @@ void HP_pc_read_skill_tree(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_read_skill_tree_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -49946,6 +51881,7 @@ int HP_pc_isUseitem(struct map_session_data *sd, int n) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_isUseitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isUseitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_isUseitem_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &n);
@@ -49972,6 +51908,7 @@ int HP_pc_show_steal(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_show_steal_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -50004,6 +51941,7 @@ int HP_pc_checkcombo(struct map_session_data *sd, struct item_data *data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_checkcombo_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct item_data *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkcombo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_checkcombo_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, data);
@@ -50030,6 +51968,7 @@ int HP_pc_calcweapontype(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_calcweapontype_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcweapontype_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_calcweapontype_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -50056,6 +51995,7 @@ int HP_pc_removecombo(struct map_session_data *sd, struct item_data *data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_removecombo_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct item_data *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_removecombo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_removecombo_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, data);
@@ -50081,6 +52021,7 @@ void HP_pc_bank_deposit(struct map_session_data *sd, int money) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_bank_deposit_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *money);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bank_deposit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_bank_deposit_pre[hIndex].func;
 			preHookFunc(sd, &money);
@@ -50106,6 +52047,7 @@ void HP_pc_bank_withdraw(struct map_session_data *sd, int money) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_bank_withdraw_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *money);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bank_withdraw_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_bank_withdraw_pre[hIndex].func;
 			preHookFunc(sd, &money);
@@ -50131,6 +52073,7 @@ void HP_pc_rental_expire(struct map_session_data *sd, int i) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_rental_expire_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int *i);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_rental_expire_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_rental_expire_pre[hIndex].func;
 			preHookFunc(sd, &i);
@@ -50156,6 +52099,7 @@ void HP_pc_scdata_received(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_scdata_received_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_scdata_received_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_scdata_received_pre[hIndex].func;
 			preHookFunc(sd);
@@ -50181,6 +52125,7 @@ void HP_pc_bound_clear(struct map_session_data *sd, enum e_item_bound_type type)
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_bound_clear_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, enum e_item_bound_type *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bound_clear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_bound_clear_pre[hIndex].func;
 			preHookFunc(sd, &type);
@@ -50207,6 +52152,7 @@ int HP_pc_expiration_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_expiration_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_expiration_timer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_expiration_timer_pre[hIndex].func;
 			retVal___ = preHookFunc(&tid, &tick, &id, &data);
@@ -50233,6 +52179,7 @@ int HP_pc_global_expiration_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pc_global_expiration_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_global_expiration_timer_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_global_expiration_timer_pre[hIndex].func;
 			retVal___ = preHookFunc(&tid, &tick, &id, &data);
@@ -50258,6 +52205,7 @@ void HP_pc_expire_check(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_expire_check_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_expire_check_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_expire_check_pre[hIndex].func;
 			preHookFunc(sd);
@@ -50283,6 +52231,7 @@ void HP_pc_autotrade_load(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_autotrade_load_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_load_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_autotrade_load_pre[hIndex].func;
 			preHookFunc();
@@ -50308,6 +52257,7 @@ void HP_pc_autotrade_update(struct map_session_data *sd, enum e_pc_autotrade_upd
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_autotrade_update_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, enum e_pc_autotrade_update_action *action);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_update_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_autotrade_update_pre[hIndex].func;
 			preHookFunc(sd, &action);
@@ -50333,6 +52283,7 @@ void HP_pc_autotrade_start(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_autotrade_start_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_start_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_autotrade_start_pre[hIndex].func;
 			preHookFunc(sd);
@@ -50358,6 +52309,7 @@ void HP_pc_autotrade_prepare(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_autotrade_prepare_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_prepare_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_autotrade_prepare_pre[hIndex].func;
 			preHookFunc(sd);
@@ -50383,6 +52335,7 @@ void HP_pc_autotrade_populate(struct map_session_data *sd) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_pc_autotrade_populate_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_populate_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pc_autotrade_populate_pre[hIndex].func;
 			preHookFunc(sd);
@@ -50410,6 +52363,7 @@ int HP_pet_init(bool minimal) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_init_pre ) {
 		int (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_init_pre[hIndex].func;
 			retVal___ = preHookFunc(&minimal);
@@ -50436,6 +52390,7 @@ int HP_pet_final(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_final_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_final_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -50462,6 +52417,7 @@ int HP_pet_hungry_val(struct pet_data *pd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_hungry_val_pre ) {
 		int (*preHookFunc) (struct pet_data *pd);
+		*HPMforce_return = false;
 		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);
@@ -50487,6 +52443,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -50513,6 +52470,7 @@ int HP_pet_create_egg(struct map_session_data *sd, int item_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_create_egg_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *item_id);
+		*HPMforce_return = false;
 		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);
@@ -50539,6 +52497,7 @@ int HP_pet_unlocktarget(struct pet_data *pd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_unlocktarget_pre ) {
 		int (*preHookFunc) (struct pet_data *pd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unlocktarget_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_unlocktarget_pre[hIndex].func;
 			retVal___ = preHookFunc(pd);
@@ -50565,6 +52524,7 @@ int HP_pet_attackskill(struct pet_data *pd, int target_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_attackskill_pre ) {
 		int (*preHookFunc) (struct pet_data *pd, int *target_id);
+		*HPMforce_return = false;
 		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);
@@ -50591,6 +52551,7 @@ int HP_pet_target_check(struct map_session_data *sd, struct block_list *bl, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_target_check_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, int *type);
+		*HPMforce_return = false;
 		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);
@@ -50617,6 +52578,7 @@ int HP_pet_sc_check(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_sc_check_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		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);
@@ -50643,6 +52605,7 @@ int HP_pet_hungry(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_hungry_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -50669,6 +52632,7 @@ int HP_pet_search_petDB_index(int key, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_search_petDB_index_pre ) {
 		int (*preHookFunc) (int *key, int *type);
+		*HPMforce_return = false;
 		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);
@@ -50695,6 +52659,7 @@ int HP_pet_hungry_timer_delete(struct pet_data *pd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_hungry_timer_delete_pre ) {
 		int (*preHookFunc) (struct pet_data *pd);
+		*HPMforce_return = false;
 		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);
@@ -50721,6 +52686,7 @@ int HP_pet_performance(struct map_session_data *sd, struct pet_data *pd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_performance_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_performance_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_performance_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, pd);
@@ -50747,6 +52713,7 @@ int HP_pet_return_egg(struct map_session_data *sd, struct pet_data *pd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_return_egg_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd);
+		*HPMforce_return = false;
 		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);
@@ -50773,6 +52740,7 @@ int HP_pet_data_init(struct map_session_data *sd, struct s_pet *petinfo) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_data_init_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct s_pet *petinfo);
+		*HPMforce_return = false;
 		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);
@@ -50799,6 +52767,7 @@ int HP_pet_birth_process(struct map_session_data *sd, struct s_pet *petinfo) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_birth_process_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct s_pet *petinfo);
+		*HPMforce_return = false;
 		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);
@@ -50825,6 +52794,7 @@ int HP_pet_recv_petdata(int account_id, struct s_pet *p, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_recv_petdata_pre ) {
 		int (*preHookFunc) (int *account_id, struct s_pet *p, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -50851,6 +52821,7 @@ int HP_pet_select_egg(struct map_session_data *sd, short egg_index) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_select_egg_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, short *egg_index);
+		*HPMforce_return = false;
 		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);
@@ -50877,6 +52848,7 @@ int HP_pet_catch_process1(struct map_session_data *sd, int target_class) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_catch_process1_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *target_class);
+		*HPMforce_return = false;
 		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);
@@ -50903,6 +52875,7 @@ int HP_pet_catch_process2(struct map_session_data *sd, int target_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_catch_process2_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *target_id);
+		*HPMforce_return = false;
 		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);
@@ -50929,6 +52902,7 @@ bool HP_pet_get_egg(int account_id, short pet_class, int pet_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_pet_get_egg_pre ) {
 		bool (*preHookFunc) (int *account_id, short *pet_class, int *pet_id);
+		*HPMforce_return = false;
 		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_class, &pet_id);
@@ -50955,6 +52929,7 @@ int HP_pet_unequipitem(struct map_session_data *sd, struct pet_data *pd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_unequipitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unequipitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_unequipitem_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, pd);
@@ -50981,6 +52956,7 @@ int HP_pet_food(struct map_session_data *sd, struct pet_data *pd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_food_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct pet_data *pd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_food_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_food_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, pd);
@@ -51007,6 +52983,7 @@ int HP_pet_ai_sub_hard_lootsearch(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -51039,6 +53016,7 @@ int HP_pet_menu(struct map_session_data *sd, int menunum) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_menu_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *menunum);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_menu_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_menu_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &menunum);
@@ -51065,6 +53043,7 @@ int HP_pet_change_name(struct map_session_data *sd, char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_change_name_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, char *name);
+		*HPMforce_return = false;
 		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);
@@ -51091,6 +53070,7 @@ int HP_pet_change_name_ack(struct map_session_data *sd, char *name, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_change_name_ack_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, char *name, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -51117,6 +53097,7 @@ int HP_pet_equipitem(struct map_session_data *sd, int index) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_equipitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_equipitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_equipitem_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &index);
@@ -51143,6 +53124,7 @@ int HP_pet_randomwalk(struct pet_data *pd, int64 tick) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_randomwalk_pre ) {
 		int (*preHookFunc) (struct pet_data *pd, int64 *tick);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_randomwalk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_randomwalk_pre[hIndex].func;
 			retVal___ = preHookFunc(pd, &tick);
@@ -51169,6 +53151,7 @@ int HP_pet_ai_sub_hard(struct pet_data *pd, struct map_session_data *sd, int64 t
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_ai_sub_hard_pre ) {
 		int (*preHookFunc) (struct pet_data *pd, struct map_session_data *sd, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -51195,6 +53178,7 @@ int HP_pet_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_ai_sub_foreachclient_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -51227,6 +53211,7 @@ int HP_pet_ai_hard(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_ai_hard_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -51253,6 +53238,7 @@ int HP_pet_delay_item_drop(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_delay_item_drop_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -51279,6 +53265,7 @@ int HP_pet_lootitem_drop(struct pet_data *pd, struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_lootitem_drop_pre ) {
 		int (*preHookFunc) (struct pet_data *pd, struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -51305,6 +53292,7 @@ int HP_pet_skill_bonus_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_skill_bonus_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -51331,6 +53319,7 @@ int HP_pet_recovery_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_recovery_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -51357,6 +53346,7 @@ int HP_pet_heal_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_heal_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -51383,6 +53373,7 @@ int HP_pet_skill_support_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_skill_support_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -51409,6 +53400,7 @@ int HP_pet_read_db(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_pet_read_db_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_read_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_pet_read_db_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -51435,6 +53427,7 @@ void HP_quest_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_quest_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_quest_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -51460,6 +53453,7 @@ void HP_quest_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_quest_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_quest_final_pre[hIndex].func;
 			preHookFunc();
@@ -51485,6 +53479,7 @@ void HP_quest_reload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_quest_reload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_quest_reload_pre[hIndex].func;
 			preHookFunc();
@@ -51511,6 +53506,7 @@ struct quest_db* HP_quest_db(int quest_id) {
 	struct quest_db* retVal___ = NULL;
 	if( HPMHooks.count.HP_quest_db_pre ) {
 		struct quest_db* (*preHookFunc) (int *quest_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_quest_db_pre[hIndex].func;
 			retVal___ = preHookFunc(&quest_id);
@@ -51537,6 +53533,7 @@ int HP_quest_pc_login(TBL_PC *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_quest_pc_login_pre ) {
 		int (*preHookFunc) (TBL_PC *sd);
+		*HPMforce_return = false;
 		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);
@@ -51563,6 +53560,7 @@ int HP_quest_add(TBL_PC *sd, int quest_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_quest_add_pre ) {
 		int (*preHookFunc) (TBL_PC *sd, int *quest_id);
+		*HPMforce_return = false;
 		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);
@@ -51589,6 +53587,7 @@ int HP_quest_change(TBL_PC *sd, int qid1, int qid2) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_quest_change_pre ) {
 		int (*preHookFunc) (TBL_PC *sd, int *qid1, int *qid2);
+		*HPMforce_return = false;
 		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);
@@ -51615,6 +53614,7 @@ int HP_quest_delete(TBL_PC *sd, int quest_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_quest_delete_pre ) {
 		int (*preHookFunc) (TBL_PC *sd, int *quest_id);
+		*HPMforce_return = false;
 		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);
@@ -51641,6 +53641,7 @@ int HP_quest_update_objective_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_quest_update_objective_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -51672,6 +53673,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -51698,6 +53700,7 @@ int HP_quest_update_status(TBL_PC *sd, int quest_id, enum quest_state qs) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_quest_update_status_pre ) {
 		int (*preHookFunc) (TBL_PC *sd, int *quest_id, enum quest_state *qs);
+		*HPMforce_return = false;
 		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);
@@ -51724,6 +53727,7 @@ int HP_quest_check(TBL_PC *sd, int quest_id, enum quest_check_type type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_quest_check_pre ) {
 		int (*preHookFunc) (TBL_PC *sd, int *quest_id, enum quest_check_type *type);
+		*HPMforce_return = false;
 		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);
@@ -51749,6 +53753,7 @@ void HP_quest_clear(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_quest_clear_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_clear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_quest_clear_pre[hIndex].func;
 			preHookFunc();
@@ -51775,6 +53780,7 @@ int HP_quest_read_db(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_quest_read_db_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_read_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_quest_read_db_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -51801,6 +53807,7 @@ void HP_script_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -51826,6 +53833,7 @@ void HP_script_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_final_pre[hIndex].func;
 			preHookFunc();
@@ -51852,6 +53860,7 @@ int HP_script_reload(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_reload_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_reload_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -51878,6 +53887,7 @@ struct script_code* HP_script_parse(const char *src, const char *file, int line,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -51904,6 +53914,7 @@ bool HP_script_add_builtin(const struct script_function *buildin, bool override)
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_script_add_builtin_pre ) {
 		bool (*preHookFunc) (const struct script_function *buildin, bool *override);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_builtin_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_add_builtin_pre[hIndex].func;
 			retVal___ = preHookFunc(buildin, &override);
@@ -51929,6 +53940,7 @@ void HP_script_parse_builtin(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_parse_builtin_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_builtin_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_parse_builtin_pre[hIndex].func;
 			preHookFunc();
@@ -51955,6 +53967,7 @@ const char* HP_script_parse_subexpr(const char *p, int limit) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_subexpr_pre ) {
 		const char* (*preHookFunc) (const char *p, int *limit);
+		*HPMforce_return = false;
 		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);
@@ -51981,6 +53994,7 @@ const char* HP_script_skip_space(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_skip_space_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -52006,6 +54020,7 @@ void HP_script_error(const char *src, const char *file, int start_line, const ch
 	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);
+		*HPMforce_return = false;
 		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);
@@ -52031,6 +54046,7 @@ void HP_script_warning(const char *src, const char *file, int start_line, const
 	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);
+		*HPMforce_return = false;
 		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);
@@ -52057,6 +54073,7 @@ bool HP_script_addScript(char *name, char *args, bool ( *func ) (struct script_s
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_script_addScript_pre ) {
 		bool (*preHookFunc) (char *name, char *args, bool ( *func ) (struct script_state *st));
+		*HPMforce_return = false;
 		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);
@@ -52083,6 +54100,7 @@ int HP_script_conv_num(struct script_state *st, struct script_data *data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_conv_num_pre ) {
 		int (*preHookFunc) (struct script_state *st, struct script_data *data);
+		*HPMforce_return = false;
 		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);
@@ -52109,6 +54127,7 @@ const char* HP_script_conv_str(struct script_state *st, struct script_data *data
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_conv_str_pre ) {
 		const char* (*preHookFunc) (struct script_state *st, struct script_data *data);
+		*HPMforce_return = false;
 		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);
@@ -52135,6 +54154,7 @@ TBL_PC* HP_script_rid2sd(struct script_state *st) {
 	TBL_PC* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_rid2sd_pre ) {
 		TBL_PC* (*preHookFunc) (struct script_state *st);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_rid2sd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_rid2sd_pre[hIndex].func;
 			retVal___ = preHookFunc(st);
@@ -52160,6 +54180,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_rid_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_detach_rid_pre[hIndex].func;
 			preHookFunc(st);
@@ -52186,6 +54207,7 @@ struct script_data* HP_script_push_val(struct script_stack *stack, enum c_op typ
 	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, int64 *val, struct reg_db *ref);
+		*HPMforce_return = false;
 		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);
@@ -52212,6 +54234,7 @@ struct script_data* HP_script_get_val(struct script_state *st, struct script_dat
 	struct script_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_get_val_pre ) {
 		struct script_data* (*preHookFunc) (struct script_state *st, struct script_data *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_get_val_pre[hIndex].func;
 			retVal___ = preHookFunc(st, data);
@@ -52238,6 +54261,7 @@ void* HP_script_get_val2(struct script_state *st, int64 uid, struct reg_db *ref)
 	void* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_get_val2_pre ) {
 		void* (*preHookFunc) (struct script_state *st, int64 *uid, struct reg_db *ref);
+		*HPMforce_return = false;
 		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);
@@ -52264,6 +54288,7 @@ struct script_data* HP_script_push_str(struct script_stack *stack, enum c_op typ
 	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);
+		*HPMforce_return = false;
 		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);
@@ -52290,6 +54315,7 @@ struct script_data* HP_script_push_copy(struct script_stack *stack, int pos) {
 	struct script_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_push_copy_pre ) {
 		struct script_data* (*preHookFunc) (struct script_stack *stack, int *pos);
+		*HPMforce_return = false;
 		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);
@@ -52315,6 +54341,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -52340,6 +54367,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -52365,6 +54393,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -52391,6 +54420,7 @@ bool HP_script_get_constant(const char *name, int *value) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_script_get_constant_pre ) {
 		bool (*preHookFunc) (const char *name, int *value);
+		*HPMforce_return = false;
 		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);
@@ -52416,6 +54446,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -52441,6 +54472,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -52466,6 +54498,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_main_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_run_main_pre[hIndex].func;
 			preHookFunc(st);
@@ -52492,6 +54525,7 @@ int HP_script_run_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_run_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -52518,6 +54552,7 @@ int HP_script_set_var(struct map_session_data *sd, char *name, void *val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_set_var_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, char *name, void *val);
+		*HPMforce_return = false;
 		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);
@@ -52543,6 +54578,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stop_instances_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_stop_instances_pre[hIndex].func;
 			preHookFunc(code);
@@ -52568,6 +54604,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_code_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_free_code_pre[hIndex].func;
 			preHookFunc(code);
@@ -52593,6 +54630,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -52619,6 +54657,7 @@ struct script_state* HP_script_alloc_state(struct script_code *rootscript, int p
 	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);
+		*HPMforce_return = false;
 		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);
@@ -52644,6 +54683,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_state_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_free_state_pre[hIndex].func;
 			preHookFunc(st);
@@ -52669,6 +54709,7 @@ void HP_script_add_pending_ref(struct script_state *st, struct reg_db *ref) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_add_pending_ref_pre ) {
 		void (*preHookFunc) (struct script_state *st, struct reg_db *ref);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_pending_ref_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_add_pending_ref_pre[hIndex].func;
 			preHookFunc(st, ref);
@@ -52694,6 +54735,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -52719,6 +54761,7 @@ void HP_script_cleararray_pc(struct map_session_data *sd, const char *varname, v
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_cleararray_pc_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, const char *varname, void *value);
+		*HPMforce_return = false;
 		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);
@@ -52744,6 +54787,7 @@ void HP_script_setarray_pc(struct map_session_data *sd, const char *varname, uin
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_setarray_pc_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, const char *varname, uint32 *idx, void *value, int *refcache);
+		*HPMforce_return = false;
 		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);
@@ -52770,6 +54814,7 @@ int HP_script_config_read(char *cfgName) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_config_read_pre ) {
 		int (*preHookFunc) (char *cfgName);
+		*HPMforce_return = false;
 		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);
@@ -52796,6 +54841,7 @@ int HP_script_add_str(const char *p) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_add_str_pre ) {
 		int (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -52822,6 +54868,7 @@ const char* HP_script_get_str(int id) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_get_str_pre ) {
 		const char* (*preHookFunc) (int *id);
+		*HPMforce_return = false;
 		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);
@@ -52848,6 +54895,7 @@ int HP_script_search_str(const char *p) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_search_str_pre ) {
 		int (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -52873,6 +54921,7 @@ void HP_script_setd_sub(struct script_state *st, struct map_session_data *sd, co
 	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 reg_db *ref);
+		*HPMforce_return = false;
 		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);
@@ -52898,6 +54947,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_attach_state_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_attach_state_pre[hIndex].func;
 			preHookFunc(st);
@@ -52924,6 +54974,7 @@ struct hQueue* HP_script_queue(int idx) {
 	struct hQueue* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_queue_pre ) {
 		struct hQueue* (*preHookFunc) (int *idx);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_queue_pre[hIndex].func;
 			retVal___ = preHookFunc(&idx);
@@ -52950,6 +55001,7 @@ bool HP_script_queue_add(int idx, int var) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_script_queue_add_pre ) {
 		bool (*preHookFunc) (int *idx, int *var);
+		*HPMforce_return = false;
 		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);
@@ -52976,6 +55028,7 @@ bool HP_script_queue_del(int idx) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_script_queue_del_pre ) {
 		bool (*preHookFunc) (int *idx);
+		*HPMforce_return = false;
 		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);
@@ -53002,6 +55055,7 @@ bool HP_script_queue_remove(int idx, int var) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_script_queue_remove_pre ) {
 		bool (*preHookFunc) (int *idx, int *var);
+		*HPMforce_return = false;
 		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);
@@ -53028,6 +55082,7 @@ int HP_script_queue_create(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_queue_create_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_create_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_queue_create_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -53053,6 +55108,7 @@ void HP_script_queue_clear(int idx) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_queue_clear_pre ) {
 		void (*preHookFunc) (int *idx);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_clear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_queue_clear_pre[hIndex].func;
 			preHookFunc(&idx);
@@ -53079,6 +55135,7 @@ const char* HP_script_parse_curly_close(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_curly_close_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53105,6 +55162,7 @@ const char* HP_script_parse_syntax_close(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_syntax_close_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53131,6 +55189,7 @@ const char* HP_script_parse_syntax_close_sub(const char *p, int *flag) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_syntax_close_sub_pre ) {
 		const char* (*preHookFunc) (const char *p, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -53157,6 +55216,7 @@ const char* HP_script_parse_syntax(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_syntax_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53183,6 +55243,7 @@ c_op HP_script_get_com(unsigned char *scriptbuf, int *pos) {
 	c_op retVal___ = C_NOP;
 	if( HPMHooks.count.HP_script_get_com_pre ) {
 		c_op (*preHookFunc) (unsigned char *scriptbuf, int *pos);
+		*HPMforce_return = false;
 		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);
@@ -53209,6 +55270,7 @@ int HP_script_get_num(unsigned char *scriptbuf, int *pos) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_get_num_pre ) {
 		int (*preHookFunc) (unsigned char *scriptbuf, int *pos);
+		*HPMforce_return = false;
 		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);
@@ -53235,6 +55297,7 @@ const char* HP_script_op2name(int op) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_op2name_pre ) {
 		const char* (*preHookFunc) (int *op);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op2name_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_op2name_pre[hIndex].func;
 			retVal___ = preHookFunc(&op);
@@ -53260,6 +55323,7 @@ void HP_script_reportsrc(struct script_state *st) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_reportsrc_pre ) {
 		void (*preHookFunc) (struct script_state *st);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportsrc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_reportsrc_pre[hIndex].func;
 			preHookFunc(st);
@@ -53285,6 +55349,7 @@ void HP_script_reportdata(struct script_data *data) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_reportdata_pre ) {
 		void (*preHookFunc) (struct script_data *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportdata_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_reportdata_pre[hIndex].func;
 			preHookFunc(data);
@@ -53310,6 +55375,7 @@ void HP_script_reportfunc(struct script_state *st) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_reportfunc_pre ) {
 		void (*preHookFunc) (struct script_state *st);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportfunc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_reportfunc_pre[hIndex].func;
 			preHookFunc(st);
@@ -53335,6 +55401,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -53360,6 +55427,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -53386,6 +55454,7 @@ unsigned int HP_script_calc_hash(const char *p) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_script_calc_hash_pre ) {
 		unsigned int (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53411,6 +55480,7 @@ void HP_script_addb(int a) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_addb_pre ) {
 		void (*preHookFunc) (int *a);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_addb_pre[hIndex].func;
 			preHookFunc(&a);
@@ -53436,6 +55506,7 @@ void HP_script_addc(int a) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_addc_pre ) {
 		void (*preHookFunc) (int *a);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_addc_pre[hIndex].func;
 			preHookFunc(&a);
@@ -53461,6 +55532,7 @@ void HP_script_addi(int a) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_addi_pre ) {
 		void (*preHookFunc) (int *a);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addi_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_addi_pre[hIndex].func;
 			preHookFunc(&a);
@@ -53486,6 +55558,7 @@ void HP_script_addl(int l) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_addl_pre ) {
 		void (*preHookFunc) (int *l);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addl_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_addl_pre[hIndex].func;
 			preHookFunc(&l);
@@ -53511,6 +55584,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -53537,6 +55611,7 @@ const char* HP_script_skip_word(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_skip_word_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53563,6 +55638,7 @@ int HP_script_add_word(const char *p) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_add_word_pre ) {
 		int (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53589,6 +55665,7 @@ const char* HP_script_parse_callfunc(const char *p, int require_paren, int is_cu
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_callfunc_pre ) {
 		const char* (*preHookFunc) (const char *p, int *require_paren, int *is_custom);
+		*HPMforce_return = false;
 		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);
@@ -53614,6 +55691,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -53640,6 +55718,7 @@ const char* HP_script_parse_variable(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_variable_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53666,6 +55745,7 @@ const char* HP_script_parse_simpleexpr(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_simpleexpr_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53692,6 +55772,7 @@ const char* HP_script_parse_expr(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_expr_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53718,6 +55799,7 @@ const char* HP_script_parse_line(const char *p) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_parse_line_pre ) {
 		const char* (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		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);
@@ -53743,6 +55825,7 @@ void HP_script_read_constdb(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_read_constdb_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_read_constdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_read_constdb_pre[hIndex].func;
 			preHookFunc();
@@ -53769,6 +55852,7 @@ const char* HP_script_print_line(StringBuf *buf, const char *p, const char *mark
 	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);
+		*HPMforce_return = false;
 		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);
@@ -53794,6 +55878,7 @@ void HP_script_errorwarning_sub(StringBuf *buf, const char *src, const char *fil
 	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);
+		*HPMforce_return = false;
 		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);
@@ -53820,6 +55905,7 @@ int HP_script_set_reg(struct script_state *st, TBL_PC *sd, int64 num, const char
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_set_reg_pre ) {
 		int (*preHookFunc) (struct script_state *st, TBL_PC *sd, int64 *num, const char *name, const void *value, struct reg_db *ref);
+		*HPMforce_return = false;
 		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);
@@ -53845,6 +55931,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stack_expand_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_stack_expand_pre[hIndex].func;
 			preHookFunc(stack);
@@ -53871,6 +55958,7 @@ struct script_data* HP_script_push_retinfo(struct script_stack *stack, struct sc
 	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, struct reg_db *ref);
+		*HPMforce_return = false;
 		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);
@@ -53896,6 +55984,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -53921,6 +56010,7 @@ void HP_script_op_2str(struct script_state *st, int op, const char *s1, const ch
 	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);
+		*HPMforce_return = false;
 		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);
@@ -53946,6 +56036,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -53971,6 +56062,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -53996,6 +56088,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -54021,6 +56114,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -54046,6 +56140,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -54072,6 +56167,7 @@ int HP_script_db_free_code_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_db_free_code_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54103,6 +56199,7 @@ void HP_script_add_autobonus(const char *autobonus) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_add_autobonus_pre ) {
 		void (*preHookFunc) (const char *autobonus);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_autobonus_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_add_autobonus_pre[hIndex].func;
 			preHookFunc(autobonus);
@@ -54129,6 +56226,7 @@ int HP_script_menu_countoptions(const char *str, int max_count, int *total) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_menu_countoptions_pre ) {
 		int (*preHookFunc) (const char *str, int *max_count, int *total);
+		*HPMforce_return = false;
 		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);
@@ -54155,6 +56253,7 @@ int HP_script_buildin_areawarp_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_areawarp_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54187,6 +56286,7 @@ int HP_script_buildin_areapercentheal_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_areapercentheal_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54218,6 +56318,7 @@ void HP_script_buildin_delitem_delete(struct map_session_data *sd, int idx, int
 	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);
+		*HPMforce_return = false;
 		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);
@@ -54244,6 +56345,7 @@ bool HP_script_buildin_delitem_search(struct map_session_data *sd, struct item *
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_script_buildin_delitem_search_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, struct item *it, bool *exact_match);
+		*HPMforce_return = false;
 		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);
@@ -54270,6 +56372,7 @@ int HP_script_buildin_killmonster_sub_strip(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_killmonster_sub_strip_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54302,6 +56405,7 @@ int HP_script_buildin_killmonster_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_killmonster_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54334,6 +56438,7 @@ int HP_script_buildin_killmonsterall_sub_strip(struct block_list *bl, va_list ap
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54366,6 +56471,7 @@ int HP_script_buildin_killmonsterall_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54398,6 +56504,7 @@ int HP_script_buildin_announce_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_announce_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54430,6 +56537,7 @@ int HP_script_buildin_getareausers_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_getareausers_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54462,6 +56570,7 @@ int HP_script_buildin_getareadropitem_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_getareadropitem_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54494,6 +56603,7 @@ int HP_script_mapflag_pvp_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_mapflag_pvp_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54526,6 +56636,7 @@ int HP_script_buildin_pvpoff_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_pvpoff_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54558,6 +56669,7 @@ int HP_script_buildin_maprespawnguildid_sub_pc(struct map_session_data *sd, va_l
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54590,6 +56702,7 @@ int HP_script_buildin_maprespawnguildid_sub_mob(struct block_list *bl, va_list a
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54622,6 +56735,7 @@ int HP_script_buildin_mobcount_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_mobcount_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54654,6 +56768,7 @@ int HP_script_playbgm_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_playbgm_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54686,6 +56801,7 @@ int HP_script_playbgm_foreachpc_sub(struct map_session_data *sd, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_playbgm_foreachpc_sub_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -54718,6 +56834,7 @@ int HP_script_soundeffect_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_soundeffect_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54750,6 +56867,7 @@ int HP_script_buildin_query_sql_sub(struct script_state *st, Sql *handle) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_query_sql_sub_pre ) {
 		int (*preHookFunc) (struct script_state *st, Sql *handle);
+		*HPMforce_return = false;
 		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);
@@ -54776,6 +56894,7 @@ int HP_script_buildin_instance_warpall_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_instance_warpall_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54808,6 +56927,7 @@ int HP_script_buildin_mobuseskill_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_buildin_mobuseskill_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54840,6 +56960,7 @@ int HP_script_cleanfloor_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_cleanfloor_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -54872,6 +56993,7 @@ int HP_script_run_func(struct script_state *st) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_run_func_pre ) {
 		int (*preHookFunc) (struct script_state *st);
+		*HPMforce_return = false;
 		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);
@@ -54898,6 +57020,7 @@ const char* HP_script_getfuncname(struct script_state *st) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_getfuncname_pre ) {
 		const char* (*preHookFunc) (struct script_state *st);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_getfuncname_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_getfuncname_pre[hIndex].func;
 			retVal___ = preHookFunc(st);
@@ -54924,6 +57047,7 @@ unsigned int HP_script_calc_hash_ci(const char *p) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_script_calc_hash_ci_pre ) {
 		unsigned int (*preHookFunc) (const char *p);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_calc_hash_ci_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_calc_hash_ci_pre[hIndex].func;
 			retVal___ = preHookFunc(p);
@@ -54950,6 +57074,7 @@ struct reg_db* HP_script_array_src(struct script_state *st, struct map_session_d
 	struct reg_db* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_array_src_pre ) {
 		struct reg_db* (*preHookFunc) (struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_src_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_src_pre[hIndex].func;
 			retVal___ = preHookFunc(st, sd, name, ref);
@@ -54975,6 +57100,7 @@ void HP_script_array_update(struct reg_db *src, int64 num, bool empty) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_array_update_pre ) {
 		void (*preHookFunc) (struct reg_db *src, int64 *num, bool *empty);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_update_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_update_pre[hIndex].func;
 			preHookFunc(src, &num, &empty);
@@ -55000,6 +57126,7 @@ void HP_script_array_delete(struct reg_db *src, struct script_array *sa) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_array_delete_pre ) {
 		void (*preHookFunc) (struct reg_db *src, struct script_array *sa);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_delete_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_delete_pre[hIndex].func;
 			preHookFunc(src, sa);
@@ -55025,6 +57152,7 @@ void HP_script_array_remove_member(struct reg_db *src, struct script_array *sa,
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_array_remove_member_pre ) {
 		void (*preHookFunc) (struct reg_db *src, struct script_array *sa, unsigned int *idx);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_remove_member_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_remove_member_pre[hIndex].func;
 			preHookFunc(src, sa, &idx);
@@ -55050,6 +57178,7 @@ void HP_script_array_add_member(struct script_array *sa, unsigned int idx) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_array_add_member_pre ) {
 		void (*preHookFunc) (struct script_array *sa, unsigned int *idx);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_add_member_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_add_member_pre[hIndex].func;
 			preHookFunc(sa, &idx);
@@ -55076,6 +57205,7 @@ unsigned int HP_script_array_size(struct script_state *st, struct map_session_da
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_script_array_size_pre ) {
 		unsigned int (*preHookFunc) (struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_size_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_size_pre[hIndex].func;
 			retVal___ = preHookFunc(st, sd, name, ref);
@@ -55102,6 +57232,7 @@ unsigned int HP_script_array_highest_key(struct script_state *st, struct map_ses
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_script_array_highest_key_pre ) {
 		unsigned int (*preHookFunc) (struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_highest_key_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_highest_key_pre[hIndex].func;
 			retVal___ = preHookFunc(st, sd, name, ref);
@@ -55128,6 +57259,7 @@ int HP_script_array_free_db(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_array_free_db_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_free_db_pre; hIndex++ ) {
 			va_list ap___copy; va_copy(ap___copy, ap);
 			preHookFunc = HPMHooks.list.HP_script_array_free_db_pre[hIndex].func;
@@ -55159,6 +57291,7 @@ void HP_script_array_ensure_zero(struct script_state *st, struct map_session_dat
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_array_ensure_zero_pre ) {
 		void (*preHookFunc) (struct script_state *st, struct map_session_data *sd, int64 *uid, struct reg_db *ref);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_ensure_zero_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_ensure_zero_pre[hIndex].func;
 			preHookFunc(st, sd, &uid, ref);
@@ -55184,6 +57317,7 @@ void HP_script_reg_destroy_single(struct map_session_data *sd, int64 reg, struct
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_reg_destroy_single_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, int64 *reg, struct script_reg_state *data);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reg_destroy_single_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_reg_destroy_single_pre[hIndex].func;
 			preHookFunc(sd, &reg, data);
@@ -55210,6 +57344,7 @@ int HP_script_reg_destroy(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_script_reg_destroy_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reg_destroy_pre; hIndex++ ) {
 			va_list ap___copy; va_copy(ap___copy, ap);
 			preHookFunc = HPMHooks.list.HP_script_reg_destroy_pre[hIndex].func;
@@ -55241,6 +57376,7 @@ void HP_script_generic_ui_array_expand(unsigned int plus) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_generic_ui_array_expand_pre ) {
 		void (*preHookFunc) (unsigned int *plus);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_generic_ui_array_expand_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_generic_ui_array_expand_pre[hIndex].func;
 			preHookFunc(&plus);
@@ -55267,6 +57403,7 @@ unsigned int* HP_script_array_cpy_list(struct script_array *sa) {
 	unsigned int* retVal___ = NULL;
 	if( HPMHooks.count.HP_script_array_cpy_list_pre ) {
 		unsigned int* (*preHookFunc) (struct script_array *sa);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_cpy_list_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_array_cpy_list_pre[hIndex].func;
 			retVal___ = preHookFunc(sa);
@@ -55292,6 +57429,7 @@ void HP_script_hardcoded_constants(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_script_hardcoded_constants_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_hardcoded_constants_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_hardcoded_constants_pre[hIndex].func;
 			preHookFunc();
@@ -55318,6 +57456,7 @@ unsigned short HP_script_mapindexname2id(struct script_state *st, const char *na
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_script_mapindexname2id_pre ) {
 		unsigned short (*preHookFunc) (struct script_state *st, const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_mapindexname2id_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_script_mapindexname2id_pre[hIndex].func;
 			retVal___ = preHookFunc(st, name);
@@ -55345,6 +57484,7 @@ bool HP_searchstore_open(struct map_session_data *sd, unsigned int uses, unsigne
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_searchstore_open_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, unsigned int *uses, unsigned short *effect);
+		*HPMforce_return = false;
 		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);
@@ -55370,6 +57510,7 @@ void HP_searchstore_query(struct map_session_data *sd, unsigned char type, unsig
 	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);
+		*HPMforce_return = false;
 		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);
@@ -55396,6 +57537,7 @@ bool HP_searchstore_querynext(struct map_session_data *sd) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_searchstore_querynext_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_querynext_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_searchstore_querynext_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -55421,6 +57563,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_next_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_searchstore_next_pre[hIndex].func;
 			preHookFunc(sd);
@@ -55446,6 +57589,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clear_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_searchstore_clear_pre[hIndex].func;
 			preHookFunc(sd);
@@ -55471,6 +57615,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_close_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_searchstore_close_pre[hIndex].func;
 			preHookFunc(sd);
@@ -55496,6 +57641,7 @@ void HP_searchstore_click(struct map_session_data *sd, int account_id, int store
 	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);
+		*HPMforce_return = false;
 		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);
@@ -55522,6 +57668,7 @@ bool HP_searchstore_queryremote(struct map_session_data *sd, int account_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_searchstore_queryremote_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, int *account_id);
+		*HPMforce_return = false;
 		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);
@@ -55547,6 +57694,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clearremote_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_searchstore_clearremote_pre[hIndex].func;
 			preHookFunc(sd);
@@ -55573,6 +57721,7 @@ bool HP_searchstore_result(struct map_session_data *sd, unsigned int store_id, i
 	bool retVal___ = false;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -55600,6 +57749,7 @@ int HP_skill_init(bool minimal) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_init_pre ) {
 		int (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_init_pre[hIndex].func;
 			retVal___ = preHookFunc(&minimal);
@@ -55626,6 +57776,7 @@ int HP_skill_final(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_final_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_final_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -55651,6 +57802,7 @@ void HP_skill_reload(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_skill_reload_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_reload_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_reload_pre[hIndex].func;
 			preHookFunc();
@@ -55676,6 +57828,7 @@ void HP_skill_read_db(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_skill_read_db_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_read_db_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_read_db_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -55702,6 +57855,7 @@ int HP_skill_get_index(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_index_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -55728,6 +57882,7 @@ int HP_skill_get_type(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_type_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -55754,6 +57909,7 @@ int HP_skill_get_hit(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_hit_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -55780,6 +57936,7 @@ int HP_skill_get_inf(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_inf_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -55806,6 +57963,7 @@ int HP_skill_get_ele(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_ele_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -55832,6 +57990,7 @@ int HP_skill_get_nk(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_nk_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -55858,6 +58017,7 @@ int HP_skill_get_max(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_max_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -55884,6 +58044,7 @@ int HP_skill_get_range(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_range_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -55910,6 +58071,7 @@ int HP_skill_get_range2(struct block_list *bl, uint16 skill_id, uint16 skill_lv)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_range2_pre ) {
 		int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -55936,6 +58098,7 @@ int HP_skill_get_splash(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_splash_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -55962,6 +58125,7 @@ int HP_skill_get_hp(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_hp_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -55988,6 +58152,7 @@ int HP_skill_get_mhp(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_mhp_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56014,6 +58179,7 @@ int HP_skill_get_sp(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_sp_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56040,6 +58206,7 @@ int HP_skill_get_state(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_state_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56066,6 +58233,7 @@ int HP_skill_get_spiritball(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_spiritball_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56092,6 +58260,7 @@ int HP_skill_get_zeny(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_zeny_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56118,6 +58287,7 @@ int HP_skill_get_num(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_num_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56144,6 +58314,7 @@ int HP_skill_get_cast(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_cast_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56170,6 +58341,7 @@ int HP_skill_get_delay(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_delay_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56196,6 +58368,7 @@ int HP_skill_get_walkdelay(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_walkdelay_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56222,6 +58395,7 @@ int HP_skill_get_time(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_time_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56248,6 +58422,7 @@ int HP_skill_get_time2(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_time2_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56274,6 +58449,7 @@ int HP_skill_get_castnodex(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_castnodex_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56300,6 +58476,7 @@ int HP_skill_get_delaynodex(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_delaynodex_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56326,6 +58503,7 @@ int HP_skill_get_castdef(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_castdef_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56352,6 +58530,7 @@ int HP_skill_get_weapontype(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_weapontype_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56378,6 +58557,7 @@ int HP_skill_get_ammotype(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_ammotype_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56404,6 +58584,7 @@ int HP_skill_get_ammo_qty(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_ammo_qty_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56430,6 +58611,7 @@ int HP_skill_get_unit_id(uint16 skill_id, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_unit_id_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -56456,6 +58638,7 @@ int HP_skill_get_inf2(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_inf2_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56482,6 +58665,7 @@ int HP_skill_get_castcancel(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_castcancel_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56508,6 +58692,7 @@ int HP_skill_get_maxcount(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_maxcount_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56534,6 +58719,7 @@ int HP_skill_get_blewcount(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_blewcount_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56560,6 +58746,7 @@ int HP_skill_get_unit_flag(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_unit_flag_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56586,6 +58773,7 @@ int HP_skill_get_unit_target(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_unit_target_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56612,6 +58800,7 @@ int HP_skill_get_unit_interval(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_unit_interval_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56638,6 +58827,7 @@ int HP_skill_get_unit_bl_target(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_unit_bl_target_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56664,6 +58854,7 @@ int HP_skill_get_unit_layout_type(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_unit_layout_type_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56690,6 +58881,7 @@ int HP_skill_get_unit_range(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_unit_range_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56716,6 +58908,7 @@ int HP_skill_get_cooldown(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_cooldown_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -56742,6 +58935,7 @@ int HP_skill_tree_get_max(uint16 skill_id, int b_class) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_tree_get_max_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, int *b_class);
+		*HPMforce_return = false;
 		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);
@@ -56768,6 +58962,7 @@ const char* HP_skill_get_name(uint16 skill_id) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_skill_get_name_pre ) {
 		const char* (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56794,6 +58989,7 @@ const char* HP_skill_get_desc(uint16 skill_id) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_skill_get_desc_pre ) {
 		const char* (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56819,6 +59015,7 @@ void HP_skill_chk(uint16 *skill_id) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_skill_chk_pre ) {
 		void (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_chk_pre[hIndex].func;
 			preHookFunc(skill_id);
@@ -56845,6 +59042,7 @@ int HP_skill_get_casttype(uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_casttype_pre ) {
 		int (*preHookFunc) (uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -56871,6 +59069,7 @@ int HP_skill_get_casttype2(uint16 index) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_casttype2_pre ) {
 		int (*preHookFunc) (uint16 *index);
+		*HPMforce_return = false;
 		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);
@@ -56897,6 +59096,7 @@ bool HP_skill_is_combo(int skill_id) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_is_combo_pre ) {
 		bool (*preHookFunc) (int *skill_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_is_combo_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_is_combo_pre[hIndex].func;
 			retVal___ = preHookFunc(&skill_id);
@@ -56923,6 +59123,7 @@ int HP_skill_name2id(const char *name) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_name2id_pre ) {
 		int (*preHookFunc) (const char *name);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_name2id_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_name2id_pre[hIndex].func;
 			retVal___ = preHookFunc(name);
@@ -56949,6 +59150,7 @@ int HP_skill_isammotype(struct map_session_data *sd, int skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_isammotype_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *skill_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_isammotype_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_isammotype_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &skill_id);
@@ -56975,6 +59177,7 @@ int HP_skill_castend_id(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_castend_id_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -57001,6 +59204,7 @@ int HP_skill_castend_pos(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_castend_pos_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -57027,6 +59231,7 @@ int HP_skill_castend_map(struct map_session_data *sd, uint16 skill_id, const cha
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_castend_map_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, const char *mapname);
+		*HPMforce_return = false;
 		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);
@@ -57053,6 +59258,7 @@ int HP_skill_cleartimerskill(struct block_list *src) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_cleartimerskill_pre ) {
 		int (*preHookFunc) (struct block_list *src);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_cleartimerskill_pre[hIndex].func;
 			retVal___ = preHookFunc(src);
@@ -57079,6 +59285,7 @@ int HP_skill_addtimerskill(struct block_list *src, int64 tick, int target, int x
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_addtimerskill_pre ) {
 		int (*preHookFunc) (struct block_list *src, int64 *tick, int *target, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int *type, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -57105,6 +59312,7 @@ int HP_skill_additional_effect(struct block_list *src, struct block_list *bl, ui
 	int retVal___ = 0;
 	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, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -57131,6 +59339,7 @@ int HP_skill_counter_additional_effect(struct block_list *src, struct block_list
 	int retVal___ = 0;
 	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, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -57157,6 +59366,7 @@ int HP_skill_blown(struct block_list *src, struct block_list *target, int count,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_blown_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *target, int *count, int8 *dir, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -57183,6 +59393,7 @@ int HP_skill_break_equip(struct block_list *bl, unsigned short where, int rate,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_break_equip_pre ) {
 		int (*preHookFunc) (struct block_list *bl, unsigned short *where, int *rate, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -57209,6 +59420,7 @@ int HP_skill_strip_equip(struct block_list *bl, unsigned short where, int rate,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_strip_equip_pre ) {
 		int (*preHookFunc) (struct block_list *bl, unsigned short *where, int *rate, int *lv, int *time);
+		*HPMforce_return = false;
 		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);
@@ -57235,6 +59447,7 @@ struct skill_unit_group* HP_skill_id2group(int group_id) {
 	struct skill_unit_group* retVal___ = NULL;
 	if( HPMHooks.count.HP_skill_id2group_pre ) {
 		struct skill_unit_group* (*preHookFunc) (int *group_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_id2group_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_id2group_pre[hIndex].func;
 			retVal___ = preHookFunc(&group_id);
@@ -57261,6 +59474,7 @@ struct skill_unit_group* HP_skill_unitsetting(struct block_list *src, uint16 ski
 	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);
+		*HPMforce_return = false;
 		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);
@@ -57287,6 +59501,7 @@ struct skill_unit* HP_skill_initunit(struct skill_unit_group *group, int idx, in
 	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);
+		*HPMforce_return = false;
 		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);
@@ -57313,6 +59528,7 @@ int HP_skill_delunit(struct skill_unit *su) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_delunit_pre ) {
 		int (*preHookFunc) (struct skill_unit *su);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delunit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_delunit_pre[hIndex].func;
 			retVal___ = preHookFunc(su);
@@ -57339,6 +59555,7 @@ struct skill_unit_group* HP_skill_init_unitgroup(struct block_list *src, int cou
 	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);
+		*HPMforce_return = false;
 		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);
@@ -57365,6 +59582,7 @@ int HP_skill_del_unitgroup(struct skill_unit_group *group, const char *file, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_del_unitgroup_pre ) {
 		int (*preHookFunc) (struct skill_unit_group *group, const char *file, int *line, const char *func);
+		*HPMforce_return = false;
 		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);
@@ -57391,6 +59609,7 @@ int HP_skill_clear_unitgroup(struct block_list *src) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_clear_unitgroup_pre ) {
 		int (*preHookFunc) (struct block_list *src);
+		*HPMforce_return = false;
 		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);
@@ -57417,6 +59636,7 @@ int HP_skill_clear_group(struct block_list *bl, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_clear_group_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -57443,6 +59663,7 @@ int HP_skill_unit_onplace(struct skill_unit *src, struct block_list *bl, int64 t
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_onplace_pre ) {
 		int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -57469,6 +59690,7 @@ int HP_skill_unit_ondamaged(struct skill_unit *src, struct block_list *bl, int64
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_ondamaged_pre ) {
 		int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *damage, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -57495,6 +59717,7 @@ int HP_skill_cast_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_cast_fix_pre ) {
 		int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -57521,6 +59744,7 @@ int HP_skill_cast_fix_sc(struct block_list *bl, int time) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_cast_fix_sc_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *time);
+		*HPMforce_return = false;
 		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);
@@ -57547,6 +59771,7 @@ int HP_skill_vf_cast_fix(struct block_list *bl, double time, uint16 skill_id, ui
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_vf_cast_fix_pre ) {
 		int (*preHookFunc) (struct block_list *bl, double *time, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -57573,6 +59798,7 @@ int HP_skill_delay_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_delay_fix_pre ) {
 		int (*preHookFunc) (struct block_list *bl, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -57599,6 +59825,7 @@ int HP_skill_check_condition_castbegin(struct map_session_data *sd, uint16 skill
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_check_condition_castbegin_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -57625,6 +59852,7 @@ int HP_skill_check_condition_castend(struct map_session_data *sd, uint16 skill_i
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_check_condition_castend_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -57651,6 +59879,7 @@ int HP_skill_consume_requirement(struct map_session_data *sd, uint16 skill_id, u
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_consume_requirement_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, short *type);
+		*HPMforce_return = false;
 		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);
@@ -57678,6 +59907,7 @@ struct skill_condition HP_skill_get_requirement(struct map_session_data *sd, uin
 	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);
+		*HPMforce_return = false;
 		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);
@@ -57704,6 +59934,7 @@ int HP_skill_check_pc_partner(struct map_session_data *sd, uint16 skill_id, uint
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -57730,6 +59961,7 @@ int HP_skill_unit_move(struct block_list *bl, int64 tick, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_move_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -57756,6 +59988,7 @@ int HP_skill_unit_onleft(uint16 skill_id, struct block_list *bl, int64 tick) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_onleft_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, struct block_list *bl, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -57782,6 +60015,7 @@ int HP_skill_unit_onout(struct skill_unit *src, struct block_list *bl, int64 tic
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_onout_pre ) {
 		int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -57808,6 +60042,7 @@ int HP_skill_unit_move_unit_group(struct skill_unit_group *group, int16 m, int16
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_move_unit_group_pre ) {
 		int (*preHookFunc) (struct skill_unit_group *group, int16 *m, int16 *dx, int16 *dy);
+		*HPMforce_return = false;
 		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);
@@ -57834,6 +60069,7 @@ int HP_skill_sit(struct map_session_data *sd, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_sit_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_sit_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &type);
@@ -57859,6 +60095,7 @@ void HP_skill_brandishspear(struct block_list *src, struct block_list *bl, uint1
 	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, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -57884,6 +60121,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_repairweapon_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_repairweapon_pre[hIndex].func;
 			preHookFunc(sd, &idx);
@@ -57909,6 +60147,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_identify_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_identify_pre[hIndex].func;
 			preHookFunc(sd, &idx);
@@ -57934,6 +60173,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_weaponrefine_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_weaponrefine_pre[hIndex].func;
 			preHookFunc(sd, &idx);
@@ -57960,6 +60200,7 @@ int HP_skill_autospell(struct map_session_data *md, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_autospell_pre ) {
 		int (*preHookFunc) (struct map_session_data *md, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -57986,6 +60227,7 @@ int HP_skill_calc_heal(struct block_list *src, struct block_list *target, uint16
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -58012,6 +60254,7 @@ bool HP_skill_check_cloaking(struct block_list *bl, struct status_change_entry *
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_check_cloaking_pre ) {
 		bool (*preHookFunc) (struct block_list *bl, struct status_change_entry *sce);
+		*HPMforce_return = false;
 		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);
@@ -58038,6 +60281,7 @@ int HP_skill_enchant_elemental_end(struct block_list *bl, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_enchant_elemental_end_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *type);
+		*HPMforce_return = false;
 		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);
@@ -58064,6 +60308,7 @@ int HP_skill_not_ok(uint16 skill_id, struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_not_ok_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -58090,6 +60335,7 @@ int HP_skill_not_ok_hom(uint16 skill_id, struct homun_data *hd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_not_ok_hom_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, struct homun_data *hd);
+		*HPMforce_return = false;
 		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);
@@ -58116,6 +60362,7 @@ int HP_skill_not_ok_mercenary(uint16 skill_id, struct mercenary_data *md) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_not_ok_mercenary_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, struct mercenary_data *md);
+		*HPMforce_return = false;
 		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);
@@ -58142,6 +60389,7 @@ int HP_skill_chastle_mob_changetarget(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_chastle_mob_changetarget_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58174,6 +60422,7 @@ int HP_skill_can_produce_mix(struct map_session_data *sd, int nameid, int trigge
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_can_produce_mix_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *nameid, int *trigger, int *qty);
+		*HPMforce_return = false;
 		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);
@@ -58200,6 +60449,7 @@ int HP_skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int namei
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -58226,6 +60476,7 @@ int HP_skill_arrow_create(struct map_session_data *sd, int nameid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_arrow_create_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		*HPMforce_return = false;
 		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);
@@ -58252,6 +60503,7 @@ int HP_skill_castend_nodamage_id(struct block_list *src, struct block_list *bl,
 	int retVal___ = 0;
 	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, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -58278,6 +60530,7 @@ int HP_skill_castend_damage_id(struct block_list *src, struct block_list *bl, ui
 	int retVal___ = 0;
 	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, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -58304,6 +60557,7 @@ int HP_skill_castend_pos2(struct block_list *src, int x, int y, uint16 skill_id,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_castend_pos2_pre ) {
 		int (*preHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -58330,6 +60584,7 @@ int HP_skill_blockpc_start(struct map_session_data *sd, uint16 skill_id, int tic
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_blockpc_start_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, int *tick);
+		*HPMforce_return = false;
 		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);
@@ -58356,6 +60611,7 @@ int HP_skill_blockhomun_start(struct homun_data *hd, uint16 skill_id, int tick)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_blockhomun_start_pre ) {
 		int (*preHookFunc) (struct homun_data *hd, uint16 *skill_id, int *tick);
+		*HPMforce_return = false;
 		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);
@@ -58382,6 +60638,7 @@ int HP_skill_blockmerc_start(struct mercenary_data *md, uint16 skill_id, int tic
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_blockmerc_start_pre ) {
 		int (*preHookFunc) (struct mercenary_data *md, uint16 *skill_id, int *tick);
+		*HPMforce_return = false;
 		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);
@@ -58408,6 +60665,7 @@ int HP_skill_attack(int attack_type, struct block_list *src, struct block_list *
 	int retVal___ = 0;
 	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, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -58434,6 +60692,7 @@ int HP_skill_attack_area(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_attack_area_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58466,6 +60725,7 @@ int HP_skill_area_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_area_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58498,6 +60758,7 @@ int HP_skill_area_sub_count(struct block_list *src, struct block_list *target, u
 	int retVal___ = 0;
 	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, int64 *tick, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -58524,6 +60785,7 @@ int HP_skill_check_unit_range(struct block_list *bl, int x, int y, uint16 skill_
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -58550,6 +60812,7 @@ int HP_skill_check_unit_range_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_check_unit_range_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58582,6 +60845,7 @@ int HP_skill_check_unit_range2(struct block_list *bl, int x, int y, uint16 skill
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -58608,6 +60872,7 @@ int HP_skill_check_unit_range2_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_check_unit_range2_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58639,6 +60904,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -58665,6 +60931,7 @@ int HP_skill_magic_reflect(struct block_list *src, struct block_list *bl, int ty
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_magic_reflect_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *bl, int *type);
+		*HPMforce_return = false;
 		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);
@@ -58691,6 +60958,7 @@ int HP_skill_onskillusage(struct map_session_data *sd, struct block_list *bl, ui
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_onskillusage_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct block_list *bl, uint16 *skill_id, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -58717,6 +60985,7 @@ int HP_skill_cell_overlap(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_cell_overlap_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58749,6 +61018,7 @@ int HP_skill_timerskill(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_timerskill_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -58775,6 +61045,7 @@ int HP_skill_trap_splash(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_trap_splash_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58807,6 +61078,7 @@ int HP_skill_check_condition_mercenary(struct block_list *bl, int skill_id, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_check_condition_mercenary_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *skill_id, int *lv, int *type);
+		*HPMforce_return = false;
 		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);
@@ -58833,6 +61105,7 @@ struct skill_unit_group* HP_skill_locate_element_field(struct block_list *bl) {
 	struct skill_unit_group* retVal___ = NULL;
 	if( HPMHooks.count.HP_skill_locate_element_field_pre ) {
 		struct skill_unit_group* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -58859,6 +61132,7 @@ int HP_skill_graffitiremover(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_graffitiremover_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58891,6 +61165,7 @@ int HP_skill_activate_reverberation(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_activate_reverberation_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58923,6 +61198,7 @@ int HP_skill_dance_overlap_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_dance_overlap_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -58955,6 +61231,7 @@ int HP_skill_dance_overlap(struct skill_unit *su, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_dance_overlap_pre ) {
 		int (*preHookFunc) (struct skill_unit *su, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -58981,6 +61258,7 @@ struct s_skill_unit_layout* HP_skill_get_unit_layout(uint16 skill_id, uint16 ski
 	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);
+		*HPMforce_return = false;
 		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);
@@ -59007,6 +61285,7 @@ int HP_skill_frostjoke_scream(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_frostjoke_scream_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59039,6 +61318,7 @@ int HP_skill_greed(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_greed_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59071,6 +61351,7 @@ int HP_skill_destroy_trap(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_destroy_trap_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59103,6 +61384,7 @@ int HP_skill_icewall_block(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_icewall_block_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59135,6 +61417,7 @@ struct skill_unit_group_tickset* HP_skill_unitgrouptickset_search(struct block_l
 	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, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -59161,6 +61444,7 @@ bool HP_skill_dance_switch(struct skill_unit *su, int flag) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_dance_switch_pre ) {
 		bool (*preHookFunc) (struct skill_unit *su, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -59187,6 +61471,7 @@ int HP_skill_check_condition_char_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_check_condition_char_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59219,6 +61504,7 @@ int HP_skill_check_condition_mob_master_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_check_condition_mob_master_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59250,6 +61536,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -59275,6 +61562,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -59301,6 +61589,7 @@ int HP_skill_get_fixed_cast(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_fixed_cast_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -59327,6 +61616,7 @@ int HP_skill_sit_count(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_sit_count_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59359,6 +61649,7 @@ int HP_skill_sit_in(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_sit_in_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59391,6 +61682,7 @@ int HP_skill_sit_out(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_sit_out_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59422,6 +61714,7 @@ void HP_skill_unitsetmapcell(struct skill_unit *src, uint16 skill_id, uint16 ski
 	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);
+		*HPMforce_return = false;
 		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);
@@ -59448,6 +61741,7 @@ int HP_skill_unit_onplace_timer(struct skill_unit *src, struct block_list *bl, i
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_onplace_timer_pre ) {
 		int (*preHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -59474,6 +61768,7 @@ int HP_skill_unit_effect(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_effect_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59506,6 +61801,7 @@ int HP_skill_unit_timer_sub_onplace(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_timer_sub_onplace_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59538,6 +61834,7 @@ int HP_skill_unit_move_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_move_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59570,6 +61867,7 @@ int HP_skill_blockpc_end(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_blockpc_end_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -59596,6 +61894,7 @@ int HP_skill_blockhomun_end(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_blockhomun_end_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -59622,6 +61921,7 @@ int HP_skill_blockmerc_end(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_blockmerc_end_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -59648,6 +61948,7 @@ int HP_skill_split_atoi(char *str, int *val) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_split_atoi_pre ) {
 		int (*preHookFunc) (char *str, int *val);
+		*HPMforce_return = false;
 		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);
@@ -59674,6 +61975,7 @@ int HP_skill_unit_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -59700,6 +62002,7 @@ int HP_skill_unit_timer_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_unit_timer_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -59731,6 +62034,7 @@ void HP_skill_init_unit_layout(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_skill_init_unit_layout_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -59757,6 +62061,7 @@ bool HP_skill_parse_row_skilldb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_skilldb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59783,6 +62088,7 @@ bool HP_skill_parse_row_requiredb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_requiredb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59809,6 +62115,7 @@ bool HP_skill_parse_row_castdb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_castdb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59835,6 +62142,7 @@ bool HP_skill_parse_row_castnodexdb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_castnodexdb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59861,6 +62169,7 @@ bool HP_skill_parse_row_unitdb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_unitdb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59887,6 +62196,7 @@ bool HP_skill_parse_row_producedb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_producedb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59913,6 +62223,7 @@ bool HP_skill_parse_row_createarrowdb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_createarrowdb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59939,6 +62250,7 @@ bool HP_skill_parse_row_abradb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_abradb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59965,6 +62277,7 @@ bool HP_skill_parse_row_spellbookdb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_spellbookdb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -59991,6 +62304,7 @@ bool HP_skill_parse_row_magicmushroomdb(char *split[], int column, int current)
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_magicmushroomdb_pre ) {
 		bool (*preHookFunc) (char *split[], int *column, int *current);
+		*HPMforce_return = false;
 		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);
@@ -60017,6 +62331,7 @@ bool HP_skill_parse_row_reproducedb(char *split[], int column, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_reproducedb_pre ) {
 		bool (*preHookFunc) (char *split[], int *column, int *current);
+		*HPMforce_return = false;
 		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);
@@ -60043,6 +62358,7 @@ bool HP_skill_parse_row_improvisedb(char *split[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_improvisedb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -60069,6 +62385,7 @@ bool HP_skill_parse_row_changematerialdb(char *split[], int columns, int current
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_parse_row_changematerialdb_pre ) {
 		bool (*preHookFunc) (char *split[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -60094,6 +62411,7 @@ void HP_skill_usave_add(struct map_session_data *sd, uint16 skill_id, uint16 ski
 	int hIndex = 0;
 	if( HPMHooks.count.HP_skill_usave_add_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -60119,6 +62437,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_trigger_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_usave_trigger_pre[hIndex].func;
 			preHookFunc(sd);
@@ -60144,6 +62463,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_load_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_cooldown_load_pre[hIndex].func;
 			preHookFunc(sd);
@@ -60170,6 +62490,7 @@ int HP_skill_spellbook(struct map_session_data *sd, int nameid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_spellbook_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_spellbook_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_spellbook_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &nameid);
@@ -60196,6 +62517,7 @@ int HP_skill_block_check(struct block_list *bl, enum sc_type type, uint16 skill_
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_block_check_pre ) {
 		int (*preHookFunc) (struct block_list *bl, enum sc_type *type, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -60222,6 +62544,7 @@ int HP_skill_detonator(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_detonator_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -60254,6 +62577,7 @@ bool HP_skill_check_camouflage(struct block_list *bl, struct status_change_entry
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_check_camouflage_pre ) {
 		bool (*preHookFunc) (struct block_list *bl, struct status_change_entry *sce);
+		*HPMforce_return = false;
 		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);
@@ -60280,6 +62604,7 @@ int HP_skill_magicdecoy(struct map_session_data *sd, int nameid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_magicdecoy_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magicdecoy_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_magicdecoy_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &nameid);
@@ -60306,6 +62631,7 @@ int HP_skill_poisoningweapon(struct map_session_data *sd, int nameid) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_poisoningweapon_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_poisoningweapon_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_poisoningweapon_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &nameid);
@@ -60332,6 +62658,7 @@ int HP_skill_select_menu(struct map_session_data *sd, uint16 skill_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_select_menu_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, uint16 *skill_id);
+		*HPMforce_return = false;
 		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);
@@ -60358,6 +62685,7 @@ int HP_skill_elementalanalysis(struct map_session_data *sd, int n, uint16 skill_
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_elementalanalysis_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n, uint16 *skill_lv, unsigned short *item_list);
+		*HPMforce_return = false;
 		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);
@@ -60384,6 +62712,7 @@ int HP_skill_changematerial(struct map_session_data *sd, int n, unsigned short *
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_changematerial_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n, unsigned short *item_list);
+		*HPMforce_return = false;
 		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);
@@ -60410,6 +62739,7 @@ int HP_skill_get_elemental_type(uint16 skill_id, uint16 skill_lv) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_elemental_type_pre ) {
 		int (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -60435,6 +62765,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_save_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_cooldown_save_pre[hIndex].func;
 			preHookFunc(sd);
@@ -60461,6 +62792,7 @@ int HP_skill_get_new_group_id(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_skill_get_new_group_id_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		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();
@@ -60487,6 +62819,7 @@ bool HP_skill_check_shadowform(struct block_list *bl, int64 damage, int hit) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_skill_check_shadowform_pre ) {
 		bool (*preHookFunc) (struct block_list *bl, int64 *damage, int *hit);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_shadowform_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_skill_check_shadowform_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, &damage, &hit);
@@ -60514,6 +62847,7 @@ int HP_status_init(bool minimal) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_init_pre ) {
 		int (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_init_pre[hIndex].func;
 			retVal___ = preHookFunc(&minimal);
@@ -60539,6 +62873,7 @@ void HP_status_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_status_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_final_pre[hIndex].func;
 			preHookFunc();
@@ -60565,6 +62900,7 @@ int HP_status_get_refine_chance(enum refine_type wlv, int refine) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_refine_chance_pre ) {
 		int (*preHookFunc) (enum refine_type *wlv, int *refine);
+		*HPMforce_return = false;
 		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);
@@ -60591,6 +62927,7 @@ sc_type HP_status_skill2sc(int skill_id) {
 	sc_type retVal___ = SC_NONE;
 	if( HPMHooks.count.HP_status_skill2sc_pre ) {
 		sc_type (*preHookFunc) (int *skill_id);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_skill2sc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_skill2sc_pre[hIndex].func;
 			retVal___ = preHookFunc(&skill_id);
@@ -60617,6 +62954,7 @@ int HP_status_sc2skill(sc_type sc) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_sc2skill_pre ) {
 		int (*preHookFunc) (sc_type *sc);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2skill_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_sc2skill_pre[hIndex].func;
 			retVal___ = preHookFunc(&sc);
@@ -60643,6 +62981,7 @@ unsigned int HP_status_sc2scb_flag(sc_type sc) {
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_status_sc2scb_flag_pre ) {
 		unsigned int (*preHookFunc) (sc_type *sc);
+		*HPMforce_return = false;
 		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);
@@ -60669,6 +63008,7 @@ int HP_status_type2relevant_bl_types(int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_type2relevant_bl_types_pre ) {
 		int (*preHookFunc) (int *type);
+		*HPMforce_return = false;
 		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);
@@ -60695,6 +63035,7 @@ int HP_status_get_sc_type(sc_type idx) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_sc_type_pre ) {
 		int (*preHookFunc) (sc_type *idx);
+		*HPMforce_return = false;
 		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);
@@ -60721,6 +63062,7 @@ int HP_status_damage(struct block_list *src, struct block_list *target, int64 hp
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -60747,6 +63089,7 @@ int HP_status_charge(struct block_list *bl, int64 hp, int64 sp) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_charge_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int64 *hp, int64 *sp);
+		*HPMforce_return = false;
 		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);
@@ -60773,6 +63116,7 @@ int HP_status_percent_change(struct block_list *src, struct block_list *target,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -60799,6 +63143,7 @@ int HP_status_set_hp(struct block_list *bl, unsigned int hp, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_set_hp_pre ) {
 		int (*preHookFunc) (struct block_list *bl, unsigned int *hp, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -60825,6 +63170,7 @@ int HP_status_set_sp(struct block_list *bl, unsigned int sp, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_set_sp_pre ) {
 		int (*preHookFunc) (struct block_list *bl, unsigned int *sp, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -60851,6 +63197,7 @@ int HP_status_heal(struct block_list *bl, int64 hp, int64 sp, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_heal_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int64 *hp, int64 *sp, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -60877,6 +63224,7 @@ int HP_status_revive(struct block_list *bl, unsigned char per_hp, unsigned char
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_revive_pre ) {
 		int (*preHookFunc) (struct block_list *bl, unsigned char *per_hp, unsigned char *per_sp);
+		*HPMforce_return = false;
 		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);
@@ -60903,6 +63251,7 @@ int HP_status_fixed_revive(struct block_list *bl, unsigned int per_hp, unsigned
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_fixed_revive_pre ) {
 		int (*preHookFunc) (struct block_list *bl, unsigned int *per_hp, unsigned int *per_sp);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_fixed_revive_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_fixed_revive_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, &per_hp, &per_sp);
@@ -60929,6 +63278,7 @@ struct regen_data* HP_status_get_regen_data(struct block_list *bl) {
 	struct regen_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_status_get_regen_data_pre ) {
 		struct regen_data* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -60955,6 +63305,7 @@ struct status_data* HP_status_get_status_data(struct block_list *bl) {
 	struct status_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_status_get_status_data_pre ) {
 		struct status_data* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -60981,6 +63332,7 @@ struct status_data* HP_status_get_base_status(struct block_list *bl) {
 	struct status_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_status_get_base_status_pre ) {
 		struct status_data* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61007,6 +63359,7 @@ const char* HP_status_get_name(struct block_list *bl) {
 	const char* retVal___ = NULL;
 	if( HPMHooks.count.HP_status_get_name_pre ) {
 		const char* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61033,6 +63386,7 @@ int HP_status_get_class(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_class_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61059,6 +63413,7 @@ int HP_status_get_lv(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_lv_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61085,6 +63440,7 @@ defType HP_status_get_def(struct block_list *bl) {
 	defType retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_def_pre ) {
 		defType (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61111,6 +63467,7 @@ unsigned short HP_status_get_speed(struct block_list *bl) {
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_speed_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61137,6 +63494,7 @@ unsigned char HP_status_calc_attack_element(struct block_list *bl, struct status
 	unsigned char retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_attack_element_pre ) {
 		unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *element);
+		*HPMforce_return = false;
 		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);
@@ -61163,6 +63521,7 @@ int HP_status_get_party_id(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_party_id_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61189,6 +63548,7 @@ int HP_status_get_guild_id(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_guild_id_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61215,6 +63575,7 @@ int HP_status_get_emblem_id(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_emblem_id_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61241,6 +63602,7 @@ int HP_status_get_mexp(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_mexp_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61267,6 +63629,7 @@ int HP_status_get_race2(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_race2_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61293,6 +63656,7 @@ struct view_data* HP_status_get_viewdata(struct block_list *bl) {
 	struct view_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_status_get_viewdata_pre ) {
 		struct view_data* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61318,6 +63682,7 @@ 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_);
+		*HPMforce_return = false;
 		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_);
@@ -61343,6 +63708,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_change_init_pre[hIndex].func;
 			preHookFunc(bl);
@@ -61369,6 +63735,7 @@ struct status_change* HP_status_get_sc(struct block_list *bl) {
 	struct status_change* retVal___ = NULL;
 	if( HPMHooks.count.HP_status_get_sc_pre ) {
 		struct status_change* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61395,6 +63762,7 @@ int HP_status_isdead(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_isdead_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isdead_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_isdead_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -61421,6 +63789,7 @@ int HP_status_isimmune(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_isimmune_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isimmune_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_isimmune_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -61447,6 +63816,7 @@ int HP_status_get_sc_def(struct block_list *src, struct block_list *bl, enum sc_
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_sc_def_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *bl, enum sc_type *type, int *rate, int *tick, int *flag);
+		*HPMforce_return = false;
 		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(src, bl, &type, &rate, &tick, &flag);
@@ -61473,6 +63843,7 @@ int HP_status_change_start(struct block_list *src, struct block_list *bl, enum s
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_change_start_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *bl, enum sc_type *type, int *rate, int *val1, int *val2, int *val3, int *val4, int *tick, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_start_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_change_start_pre[hIndex].func;
 			retVal___ = preHookFunc(src, bl, &type, &rate, &val1, &val2, &val3, &val4, &tick, &flag);
@@ -61499,6 +63870,7 @@ int HP_status_change_end_(struct block_list *bl, enum sc_type type, int tid, con
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -61525,6 +63897,7 @@ int HP_status_kaahi_heal_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_kaahi_heal_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -61551,6 +63924,7 @@ int HP_status_change_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_change_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -61577,6 +63951,7 @@ int HP_status_change_timer_sub(struct block_list *bl, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_change_timer_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -61609,6 +63984,7 @@ int HP_status_change_clear(struct block_list *bl, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_change_clear_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *type);
+		*HPMforce_return = false;
 		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);
@@ -61635,6 +64011,7 @@ int HP_status_change_clear_buffs(struct block_list *bl, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_change_clear_buffs_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *type);
+		*HPMforce_return = false;
 		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);
@@ -61660,6 +64037,7 @@ void HP_status_calc_bl_(struct block_list *bl, enum scb_flag flag, enum e_status
 	int hIndex = 0;
 	if( HPMHooks.count.HP_status_calc_bl__pre ) {
 		void (*preHookFunc) (struct block_list *bl, enum scb_flag *flag, enum e_status_calc_opt *opt);
+		*HPMforce_return = false;
 		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, &opt);
@@ -61686,6 +64064,7 @@ int HP_status_calc_mob_(struct mob_data *md, enum e_status_calc_opt opt) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_mob__pre ) {
 		int (*preHookFunc) (struct mob_data *md, enum e_status_calc_opt *opt);
+		*HPMforce_return = false;
 		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, &opt);
@@ -61712,6 +64091,7 @@ int HP_status_calc_pet_(struct pet_data *pd, enum e_status_calc_opt opt) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_pet__pre ) {
 		int (*preHookFunc) (struct pet_data *pd, enum e_status_calc_opt *opt);
+		*HPMforce_return = false;
 		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, &opt);
@@ -61738,6 +64118,7 @@ int HP_status_calc_pc_(struct map_session_data *sd, enum e_status_calc_opt opt)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_pc__pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, enum e_status_calc_opt *opt);
+		*HPMforce_return = false;
 		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, &opt);
@@ -61764,6 +64145,7 @@ int HP_status_calc_homunculus_(struct homun_data *hd, enum e_status_calc_opt opt
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_homunculus__pre ) {
 		int (*preHookFunc) (struct homun_data *hd, enum e_status_calc_opt *opt);
+		*HPMforce_return = false;
 		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, &opt);
@@ -61790,6 +64172,7 @@ int HP_status_calc_mercenary_(struct mercenary_data *md, enum e_status_calc_opt
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_mercenary__pre ) {
 		int (*preHookFunc) (struct mercenary_data *md, enum e_status_calc_opt *opt);
+		*HPMforce_return = false;
 		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, &opt);
@@ -61816,6 +64199,7 @@ int HP_status_calc_elemental_(struct elemental_data *ed, enum e_status_calc_opt
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_elemental__pre ) {
 		int (*preHookFunc) (struct elemental_data *ed, enum e_status_calc_opt *opt);
+		*HPMforce_return = false;
 		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, &opt);
@@ -61841,6 +64225,7 @@ void HP_status_calc_misc(struct block_list *bl, struct status_data *st, int leve
 	int hIndex = 0;
 	if( HPMHooks.count.HP_status_calc_misc_pre ) {
 		void (*preHookFunc) (struct block_list *bl, struct status_data *st, int *level);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_misc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_calc_misc_pre[hIndex].func;
 			preHookFunc(bl, st, &level);
@@ -61866,6 +64251,7 @@ void HP_status_calc_regen(struct block_list *bl, struct status_data *st, struct
 	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);
+		*HPMforce_return = false;
 		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);
@@ -61891,6 +64277,7 @@ void HP_status_calc_regen_rate(struct block_list *bl, struct regen_data *regen,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -61917,6 +64304,7 @@ int HP_status_check_skilluse(struct block_list *src, struct block_list *target,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_check_skilluse_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -61943,6 +64331,7 @@ int HP_status_check_visibility(struct block_list *src, struct block_list *target
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_check_visibility_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *target);
+		*HPMforce_return = false;
 		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);
@@ -61969,6 +64358,7 @@ int HP_status_change_spread(struct block_list *src, struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_change_spread_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -61995,6 +64385,7 @@ defType HP_status_calc_def(struct block_list *bl, struct status_change *sc, int
 	defType retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_def_pre ) {
 		defType (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *def, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62021,6 +64412,7 @@ short HP_status_calc_def2(struct block_list *bl, struct status_change *sc, int d
 	short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_def2_pre ) {
 		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *def2, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62047,6 +64439,7 @@ defType HP_status_calc_mdef(struct block_list *bl, struct status_change *sc, int
 	defType retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_mdef_pre ) {
 		defType (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *mdef, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62073,6 +64466,7 @@ short HP_status_calc_mdef2(struct block_list *bl, struct status_change *sc, int
 	short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_mdef2_pre ) {
 		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *mdef2, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62099,6 +64493,7 @@ unsigned short HP_status_calc_batk(struct block_list *bl, struct status_change *
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_batk_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *batk, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62125,6 +64520,7 @@ unsigned short HP_status_base_matk(const struct status_data *st, int level) {
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_base_matk_pre ) {
 		unsigned short (*preHookFunc) (const struct status_data *st, int *level);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_base_matk_pre[hIndex].func;
 			retVal___ = preHookFunc(st, &level);
@@ -62151,6 +64547,7 @@ int HP_status_get_weapon_atk(struct block_list *src, struct weapon_atk *watk, in
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_weapon_atk_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct weapon_atk *watk, int *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_weapon_atk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_get_weapon_atk_pre[hIndex].func;
 			retVal___ = preHookFunc(src, watk, &flag);
@@ -62177,6 +64574,7 @@ int HP_status_get_total_mdef(struct block_list *src) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_total_mdef_pre ) {
 		int (*preHookFunc) (struct block_list *src);
+		*HPMforce_return = false;
 		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);
@@ -62203,6 +64601,7 @@ int HP_status_get_total_def(struct block_list *src) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_total_def_pre ) {
 		int (*preHookFunc) (struct block_list *src);
+		*HPMforce_return = false;
 		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);
@@ -62229,6 +64628,7 @@ int HP_status_get_matk(struct block_list *src, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_get_matk_pre ) {
 		int (*preHookFunc) (struct block_list *src, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -62255,6 +64655,7 @@ int HP_status_readdb(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_readdb_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_readdb_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -62280,6 +64681,7 @@ void HP_status_initChangeTables(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_status_initChangeTables_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initChangeTables_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_initChangeTables_pre[hIndex].func;
 			preHookFunc();
@@ -62305,6 +64707,7 @@ void HP_status_initDummyData(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_status_initDummyData_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initDummyData_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_initDummyData_pre[hIndex].func;
 			preHookFunc();
@@ -62331,6 +64734,7 @@ int HP_status_base_amotion_pc(struct map_session_data *sd, struct status_data *s
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_base_amotion_pc_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct status_data *st);
+		*HPMforce_return = false;
 		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);
@@ -62357,6 +64761,7 @@ unsigned short HP_status_base_atk(const struct block_list *bl, const struct stat
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_base_atk_pre ) {
 		unsigned short (*preHookFunc) (const struct block_list *bl, const struct status_data *st);
+		*HPMforce_return = false;
 		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);
@@ -62382,6 +64787,7 @@ void HP_status_calc_sigma(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_status_calc_sigma_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_sigma_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_calc_sigma_pre[hIndex].func;
 			preHookFunc();
@@ -62408,6 +64814,7 @@ unsigned int HP_status_base_pc_maxhp(struct map_session_data *sd, struct status_
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_status_base_pc_maxhp_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd, struct status_data *st);
+		*HPMforce_return = false;
 		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);
@@ -62434,6 +64841,7 @@ unsigned int HP_status_base_pc_maxsp(struct map_session_data *sd, struct status_
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_status_base_pc_maxsp_pre ) {
 		unsigned int (*preHookFunc) (struct map_session_data *sd, struct status_data *st);
+		*HPMforce_return = false;
 		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);
@@ -62460,6 +64868,7 @@ int HP_status_calc_npc_(struct npc_data *nd, enum e_status_calc_opt opt) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_npc__pre ) {
 		int (*preHookFunc) (struct npc_data *nd, enum e_status_calc_opt *opt);
+		*HPMforce_return = false;
 		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, &opt);
@@ -62486,6 +64895,7 @@ unsigned short HP_status_calc_str(struct block_list *bl, struct status_change *s
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_str_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *str);
+		*HPMforce_return = false;
 		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);
@@ -62512,6 +64922,7 @@ unsigned short HP_status_calc_agi(struct block_list *bl, struct status_change *s
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_agi_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *agi);
+		*HPMforce_return = false;
 		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);
@@ -62538,6 +64949,7 @@ unsigned short HP_status_calc_vit(struct block_list *bl, struct status_change *s
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_vit_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *vit);
+		*HPMforce_return = false;
 		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);
@@ -62564,6 +64976,7 @@ unsigned short HP_status_calc_int(struct block_list *bl, struct status_change *s
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_int_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *int_);
+		*HPMforce_return = false;
 		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_);
@@ -62590,6 +65003,7 @@ unsigned short HP_status_calc_dex(struct block_list *bl, struct status_change *s
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_dex_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *dex);
+		*HPMforce_return = false;
 		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);
@@ -62616,6 +65030,7 @@ unsigned short HP_status_calc_luk(struct block_list *bl, struct status_change *s
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_luk_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *luk);
+		*HPMforce_return = false;
 		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);
@@ -62642,6 +65057,7 @@ unsigned short HP_status_calc_watk(struct block_list *bl, struct status_change *
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_watk_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *watk, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62668,6 +65084,7 @@ unsigned short HP_status_calc_matk(struct block_list *bl, struct status_change *
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_matk_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *matk, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62694,6 +65111,7 @@ signed short HP_status_calc_hit(struct block_list *bl, struct status_change *sc,
 	signed short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_hit_pre ) {
 		signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *hit, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62720,6 +65138,7 @@ signed short HP_status_calc_critical(struct block_list *bl, struct status_change
 	signed short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_critical_pre ) {
 		signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *critical, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62746,6 +65165,7 @@ signed short HP_status_calc_flee(struct block_list *bl, struct status_change *sc
 	signed short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_flee_pre ) {
 		signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *flee, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62772,6 +65192,7 @@ signed short HP_status_calc_flee2(struct block_list *bl, struct status_change *s
 	signed short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_flee2_pre ) {
 		signed short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *flee2, bool *viewable);
+		*HPMforce_return = false;
 		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);
@@ -62798,6 +65219,7 @@ unsigned short HP_status_calc_speed(struct block_list *bl, struct status_change
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_speed_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *speed);
+		*HPMforce_return = false;
 		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);
@@ -62824,6 +65246,7 @@ short HP_status_calc_aspd_rate(struct block_list *bl, struct status_change *sc,
 	short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_aspd_rate_pre ) {
 		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *aspd_rate);
+		*HPMforce_return = false;
 		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);
@@ -62850,6 +65273,7 @@ unsigned short HP_status_calc_dmotion(struct block_list *bl, struct status_chang
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_dmotion_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *dmotion);
+		*HPMforce_return = false;
 		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);
@@ -62876,6 +65300,7 @@ short HP_status_calc_aspd(struct block_list *bl, struct status_change *sc, short
 	short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_aspd_pre ) {
 		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, short *flag);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_calc_aspd_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, sc, &flag);
@@ -62902,6 +65327,7 @@ short HP_status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, i
 	short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_fix_aspd_pre ) {
 		short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *aspd);
+		*HPMforce_return = false;
 		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);
@@ -62928,6 +65354,7 @@ unsigned int HP_status_calc_maxhp(struct block_list *bl, struct status_change *s
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_maxhp_pre ) {
 		unsigned int (*preHookFunc) (struct block_list *bl, struct status_change *sc, uint64 *maxhp);
+		*HPMforce_return = false;
 		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);
@@ -62954,6 +65381,7 @@ unsigned int HP_status_calc_maxsp(struct block_list *bl, struct status_change *s
 	unsigned int retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_maxsp_pre ) {
 		unsigned int (*preHookFunc) (struct block_list *bl, struct status_change *sc, unsigned int *maxsp);
+		*HPMforce_return = false;
 		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);
@@ -62980,6 +65408,7 @@ unsigned char HP_status_calc_element(struct block_list *bl, struct status_change
 	unsigned char retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_element_pre ) {
 		unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *element);
+		*HPMforce_return = false;
 		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);
@@ -63006,6 +65435,7 @@ unsigned char HP_status_calc_element_lv(struct block_list *bl, struct status_cha
 	unsigned char retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_element_lv_pre ) {
 		unsigned char (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *lv);
+		*HPMforce_return = false;
 		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);
@@ -63032,6 +65462,7 @@ unsigned short HP_status_calc_mode(struct block_list *bl, struct status_change *
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_mode_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *mode);
+		*HPMforce_return = false;
 		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);
@@ -63058,6 +65489,7 @@ unsigned short HP_status_calc_ematk(struct block_list *bl, struct status_change
 	unsigned short retVal___ = 0;
 	if( HPMHooks.count.HP_status_calc_ematk_pre ) {
 		unsigned short (*preHookFunc) (struct block_list *bl, struct status_change *sc, int *matk);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_ematk_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_status_calc_ematk_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, sc, &matk);
@@ -63083,6 +65515,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -63108,6 +65541,7 @@ void HP_status_display_add(struct map_session_data *sd, enum sc_type type, int d
 	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);
+		*HPMforce_return = false;
 		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);
@@ -63133,6 +65567,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -63159,6 +65594,7 @@ int HP_status_natural_heal(struct block_list *bl, va_list args) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_natural_heal_pre ) {
 		int (*preHookFunc) (struct block_list *bl, va_list args);
+		*HPMforce_return = false;
 		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;
@@ -63191,6 +65627,7 @@ int HP_status_natural_heal_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_status_natural_heal_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -63217,6 +65654,7 @@ bool HP_status_readdb_job1(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_status_readdb_job1_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -63243,6 +65681,7 @@ bool HP_status_readdb_job2(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_status_readdb_job2_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -63269,6 +65708,7 @@ bool HP_status_readdb_sizefix(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_status_readdb_sizefix_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -63295,6 +65735,7 @@ bool HP_status_readdb_refine(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_status_readdb_refine_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -63321,6 +65762,7 @@ bool HP_status_readdb_scconfig(char *fields[], int columns, int current) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_status_readdb_scconfig_pre ) {
 		bool (*preHookFunc) (char *fields[], int *columns, int *current);
+		*HPMforce_return = false;
 		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);
@@ -63347,6 +65789,7 @@ void HP_storage_reconnect(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_storage_reconnect_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_storage_reconnect_pre[hIndex].func;
 			preHookFunc();
@@ -63373,6 +65816,7 @@ int HP_storage_delitem(struct map_session_data *sd, int n, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_delitem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *n, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -63399,6 +65843,7 @@ int HP_storage_open(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_open_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_open_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_storage_open_pre[hIndex].func;
 			retVal___ = preHookFunc(sd);
@@ -63425,6 +65870,7 @@ int HP_storage_add(struct map_session_data *sd, int index, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_add_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -63451,6 +65897,7 @@ int HP_storage_get(struct map_session_data *sd, int index, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_get_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -63477,6 +65924,7 @@ int HP_storage_additem(struct map_session_data *sd, struct item *item_data, int
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_additem_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct item *item_data, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -63503,6 +65951,7 @@ int HP_storage_addfromcart(struct map_session_data *sd, int index, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_addfromcart_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -63529,6 +65978,7 @@ int HP_storage_gettocart(struct map_session_data *sd, int index, int amount) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_gettocart_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, int *index, int *amount);
+		*HPMforce_return = false;
 		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);
@@ -63554,6 +66004,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_close_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_storage_close_pre[hIndex].func;
 			preHookFunc(sd);
@@ -63579,6 +66030,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -63605,6 +66057,7 @@ int HP_storage_comp_item(const void *_i1, const void *_i2) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_comp_item_pre ) {
 		int (*preHookFunc) (const void *_i1, const void *_i2);
+		*HPMforce_return = false;
 		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);
@@ -63630,6 +66083,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_sortitem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_storage_sortitem_pre[hIndex].func;
 			preHookFunc(items, &size);
@@ -63656,6 +66110,7 @@ int HP_storage_reconnect_sub(DBKey key, DBData *data, va_list ap) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_storage_reconnect_sub_pre ) {
 		int (*preHookFunc) (DBKey *key, DBData *data, va_list ap);
+		*HPMforce_return = false;
 		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;
@@ -63688,6 +66143,7 @@ void HP_trade_request(struct map_session_data *sd, struct map_session_data *targ
 	int hIndex = 0;
 	if( HPMHooks.count.HP_trade_request_pre ) {
 		void (*preHookFunc) (struct map_session_data *sd, struct map_session_data *target_sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_request_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_trade_request_pre[hIndex].func;
 			preHookFunc(sd, target_sd);
@@ -63713,6 +66169,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ack_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_trade_ack_pre[hIndex].func;
 			preHookFunc(sd, &type);
@@ -63739,6 +66196,7 @@ int HP_trade_check_impossible(struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_trade_check_impossible_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd);
+		*HPMforce_return = false;
 		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);
@@ -63765,6 +66223,7 @@ int HP_trade_check(struct map_session_data *sd, struct map_session_data *tsd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_trade_check_pre ) {
 		int (*preHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_trade_check_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, tsd);
@@ -63790,6 +66249,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_additem_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_trade_additem_pre[hIndex].func;
 			preHookFunc(sd, &index, &amount);
@@ -63815,6 +66275,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_addzeny_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_trade_addzeny_pre[hIndex].func;
 			preHookFunc(sd, &amount);
@@ -63840,6 +66301,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ok_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_trade_ok_pre[hIndex].func;
 			preHookFunc(sd);
@@ -63865,6 +66327,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_cancel_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_trade_cancel_pre[hIndex].func;
 			preHookFunc(sd);
@@ -63890,6 +66353,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_commit_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_trade_commit_pre[hIndex].func;
 			preHookFunc(sd);
@@ -63917,6 +66381,7 @@ int HP_unit_init(bool minimal) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_init_pre ) {
 		int (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_init_pre[hIndex].func;
 			retVal___ = preHookFunc(&minimal);
@@ -63943,6 +66408,7 @@ int HP_unit_final(void) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_final_pre ) {
 		int (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_final_pre[hIndex].func;
 			retVal___ = preHookFunc();
@@ -63969,6 +66435,7 @@ struct unit_data* HP_unit_bl2ud(struct block_list *bl) {
 	struct unit_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_unit_bl2ud_pre ) {
 		struct unit_data* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_bl2ud_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -63995,6 +66462,7 @@ struct unit_data* HP_unit_bl2ud2(struct block_list *bl) {
 	struct unit_data* retVal___ = NULL;
 	if( HPMHooks.count.HP_unit_bl2ud2_pre ) {
 		struct unit_data* (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud2_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_bl2ud2_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -64021,6 +66489,7 @@ int HP_unit_attack_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_attack_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -64047,6 +66516,7 @@ int HP_unit_walktoxy_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_walktoxy_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -64073,6 +66543,7 @@ int HP_unit_walktoxy_sub(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_walktoxy_sub_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -64099,6 +66570,7 @@ int HP_unit_delay_walktoxy_timer(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_delay_walktoxy_timer_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -64125,6 +66597,7 @@ int HP_unit_walktoxy(struct block_list *bl, short x, short y, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_walktoxy_pre ) {
 		int (*preHookFunc) (struct block_list *bl, short *x, short *y, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -64151,6 +66624,7 @@ int HP_unit_walktobl_sub(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_walktobl_sub_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -64177,6 +66651,7 @@ int HP_unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, i
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_walktobl_pre ) {
 		int (*preHookFunc) (struct block_list *bl, struct block_list *tbl, int *range, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -64203,6 +66678,7 @@ int HP_unit_run(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_run_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_run_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -64229,6 +66705,7 @@ int HP_unit_wugdash(struct block_list *bl, struct map_session_data *sd) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_wugdash_pre ) {
 		int (*preHookFunc) (struct block_list *bl, struct map_session_data *sd);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_wugdash_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_wugdash_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, sd);
@@ -64255,6 +66732,7 @@ int HP_unit_escape(struct block_list *bl, struct block_list *target, short dist)
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_escape_pre ) {
 		int (*preHookFunc) (struct block_list *bl, struct block_list *target, short *dist);
+		*HPMforce_return = false;
 		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);
@@ -64281,6 +66759,7 @@ int HP_unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, b
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_movepos_pre ) {
 		int (*preHookFunc) (struct block_list *bl, short *dst_x, short *dst_y, int *easy, bool *checkpath);
+		*HPMforce_return = false;
 		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);
@@ -64307,6 +66786,7 @@ int HP_unit_setdir(struct block_list *bl, unsigned char dir) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_setdir_pre ) {
 		int (*preHookFunc) (struct block_list *bl, unsigned char *dir);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_setdir_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_setdir_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, &dir);
@@ -64333,6 +66813,7 @@ uint8 HP_unit_getdir(struct block_list *bl) {
 	uint8 retVal___ = 0;
 	if( HPMHooks.count.HP_unit_getdir_pre ) {
 		uint8 (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_getdir_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_getdir_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -64359,6 +66840,7 @@ int HP_unit_blown(struct block_list *bl, int dx, int dy, int count, int flag) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_blown_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *dx, int *dy, int *count, int *flag);
+		*HPMforce_return = false;
 		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);
@@ -64385,6 +66867,7 @@ int HP_unit_warp(struct block_list *bl, short m, short x, short y, clr_type type
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_warp_pre ) {
 		int (*preHookFunc) (struct block_list *bl, short *m, short *x, short *y, clr_type *type);
+		*HPMforce_return = false;
 		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);
@@ -64411,6 +66894,7 @@ int HP_unit_stop_walking(struct block_list *bl, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_stop_walking_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *type);
+		*HPMforce_return = false;
 		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);
@@ -64437,6 +66921,7 @@ int HP_unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id,
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_skilluse_id_pre ) {
 		int (*preHookFunc) (struct block_list *src, int *target_id, uint16 *skill_id, uint16 *skill_lv);
+		*HPMforce_return = false;
 		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);
@@ -64463,6 +66948,7 @@ int HP_unit_is_walking(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_is_walking_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -64489,6 +66975,7 @@ int HP_unit_can_move(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_can_move_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -64515,6 +67002,7 @@ int HP_unit_resume_running(int tid, int64 tick, int id, intptr_t data) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_resume_running_pre ) {
 		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
+		*HPMforce_return = false;
 		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);
@@ -64541,6 +67029,7 @@ int HP_unit_set_walkdelay(struct block_list *bl, int64 tick, int delay, int type
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_set_walkdelay_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int64 *tick, int *delay, int *type);
+		*HPMforce_return = false;
 		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);
@@ -64567,6 +67056,7 @@ int HP_unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -64593,6 +67083,7 @@ int HP_unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, u
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -64619,6 +67110,7 @@ int HP_unit_skilluse_pos2(struct block_list *src, short skill_x, short skill_y,
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -64645,6 +67137,7 @@ int HP_unit_set_target(struct unit_data *ud, int target_id) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_set_target_pre ) {
 		int (*preHookFunc) (struct unit_data *ud, int *target_id);
+		*HPMforce_return = false;
 		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);
@@ -64671,6 +67164,7 @@ int HP_unit_stop_attack(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_stop_attack_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -64697,6 +67191,7 @@ int HP_unit_unattackable(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_unattackable_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_unattackable_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_unattackable_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -64723,6 +67218,7 @@ int HP_unit_attack(struct block_list *src, int target_id, int continuous) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_attack_pre ) {
 		int (*preHookFunc) (struct block_list *src, int *target_id, int *continuous);
+		*HPMforce_return = false;
 		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);
@@ -64749,6 +67245,7 @@ int HP_unit_cancel_combo(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_cancel_combo_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		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);
@@ -64775,6 +67272,7 @@ bool HP_unit_can_reach_pos(struct block_list *bl, int x, int y, int easy) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_unit_can_reach_pos_pre ) {
 		bool (*preHookFunc) (struct block_list *bl, int *x, int *y, int *easy);
+		*HPMforce_return = false;
 		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);
@@ -64801,6 +67299,7 @@ bool HP_unit_can_reach_bl(struct block_list *bl, struct block_list *tbl, int ran
 	bool retVal___ = false;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -64827,6 +67326,7 @@ int HP_unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_calc_pos_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *tx, int *ty, uint8 *dir);
+		*HPMforce_return = false;
 		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);
@@ -64853,6 +67353,7 @@ int HP_unit_attack_timer_sub(struct block_list *src, int tid, int64 tick) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_attack_timer_sub_pre ) {
 		int (*preHookFunc) (struct block_list *src, int *tid, int64 *tick);
+		*HPMforce_return = false;
 		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);
@@ -64879,6 +67380,7 @@ int HP_unit_skillcastcancel(struct block_list *bl, int type) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_skillcastcancel_pre ) {
 		int (*preHookFunc) (struct block_list *bl, int *type);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skillcastcancel_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_skillcastcancel_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, &type);
@@ -64904,6 +67406,7 @@ void HP_unit_dataset(struct block_list *bl) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_unit_dataset_pre ) {
 		void (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_dataset_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_dataset_pre[hIndex].func;
 			preHookFunc(bl);
@@ -64930,6 +67433,7 @@ int HP_unit_counttargeted(struct block_list *bl) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_counttargeted_pre ) {
 		int (*preHookFunc) (struct block_list *bl);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_counttargeted_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_counttargeted_pre[hIndex].func;
 			retVal___ = preHookFunc(bl);
@@ -64956,6 +67460,7 @@ int HP_unit_fixdamage(struct block_list *src, struct block_list *target, int sde
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_fixdamage_pre ) {
 		int (*preHookFunc) (struct block_list *src, struct block_list *target, int *sdelay, int *ddelay, int64 *damage, short *div, unsigned char *type, int64 *damage2);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_fixdamage_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_fixdamage_pre[hIndex].func;
 			retVal___ = preHookFunc(src, target, &sdelay, &ddelay, &damage, &div, &type, &damage2);
@@ -64982,6 +67487,7 @@ int HP_unit_changeviewsize(struct block_list *bl, short size) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_changeviewsize_pre ) {
 		int (*preHookFunc) (struct block_list *bl, short *size);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_changeviewsize_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_changeviewsize_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, &size);
@@ -65008,6 +67514,7 @@ int HP_unit_remove_map(struct block_list *bl, clr_type clrtype, const char *file
 	int retVal___ = 0;
 	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);
+		*HPMforce_return = false;
 		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);
@@ -65033,6 +67540,7 @@ 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);
+		*HPMforce_return = false;
 		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);
@@ -65058,6 +67566,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_pc_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_free_pc_pre[hIndex].func;
 			preHookFunc(sd);
@@ -65084,6 +67593,7 @@ int HP_unit_free(struct block_list *bl, clr_type clrtype) {
 	int retVal___ = 0;
 	if( HPMHooks.count.HP_unit_free_pre ) {
 		int (*preHookFunc) (struct block_list *bl, clr_type *clrtype);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_unit_free_pre[hIndex].func;
 			retVal___ = preHookFunc(bl, &clrtype);
@@ -65110,6 +67620,7 @@ void HP_vending_init(bool minimal) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_vending_init_pre ) {
 		void (*preHookFunc) (bool *minimal);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_init_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_vending_init_pre[hIndex].func;
 			preHookFunc(&minimal);
@@ -65135,6 +67646,7 @@ void HP_vending_final(void) {
 	int hIndex = 0;
 	if( HPMHooks.count.HP_vending_final_pre ) {
 		void (*preHookFunc) (void);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_final_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_vending_final_pre[hIndex].func;
 			preHookFunc();
@@ -65160,6 +67672,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_close_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_vending_close_pre[hIndex].func;
 			preHookFunc(sd);
@@ -65185,6 +67698,7 @@ void HP_vending_open(struct map_session_data *sd, const char *message, const uin
 	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);
+		*HPMforce_return = false;
 		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);
@@ -65210,6 +67724,7 @@ 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);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_list_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_vending_list_pre[hIndex].func;
 			preHookFunc(sd, &id);
@@ -65235,6 +67750,7 @@ void HP_vending_purchase(struct map_session_data *sd, int aid, unsigned int uid,
 	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);
+		*HPMforce_return = false;
 		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);
@@ -65261,6 +67777,7 @@ bool HP_vending_search(struct map_session_data *sd, unsigned short nameid) {
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_vending_search_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, unsigned short *nameid);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_search_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_vending_search_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, &nameid);
@@ -65287,6 +67804,7 @@ bool HP_vending_searchall(struct map_session_data *sd, const struct s_search_sto
 	bool retVal___ = false;
 	if( HPMHooks.count.HP_vending_searchall_pre ) {
 		bool (*preHookFunc) (struct map_session_data *sd, const struct s_search_store_search *s);
+		*HPMforce_return = false;
 		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_searchall_pre; hIndex++ ) {
 			preHookFunc = HPMHooks.list.HP_vending_searchall_pre[hIndex].func;
 			retVal___ = preHookFunc(sd, s);