/**
 * This file is part of Hercules.
 * http://herc.ws - http://github.com/HerculesWS/Hercules
 *
 * Copyright (C) 2013-2016  Hercules Dev Team
 *
 * Hercules is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

/*
 * NOTE: This file was auto-generated and should never be manually edited,
 *       as it will get overwritten.
 */

/* GENERATED FILE DO NOT EDIT */

/* HCache_interface */
void HP_HCache_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_HCache_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_HCache_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.HCache.init();
	}
	if( HPMHooks.count.HP_HCache_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_HCache_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_HCache_check(const char *file) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_HCache_check_pre ) {
		bool (*preHookFunc) (const char **file);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_HCache_check_pre[hIndex].func;
			retVal___ = preHookFunc(&file);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.HCache.check(file);
	}
	if( HPMHooks.count.HP_HCache_check_post ) {
		bool (*postHookFunc) (bool retVal___, const char *file);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_HCache_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, file);
		}
	}
	return retVal___;
}
FILE* HP_HCache_open(const char *file, const char *opt) {
	int hIndex = 0;
	FILE* retVal___ = NULL;
	if( HPMHooks.count.HP_HCache_open_pre ) {
		FILE* (*preHookFunc) (const char **file, const char **opt);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_HCache_open_pre[hIndex].func;
			retVal___ = preHookFunc(&file, &opt);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.HCache.open(file, opt);
	}
	if( HPMHooks.count.HP_HCache_open_post ) {
		FILE* (*postHookFunc) (FILE* retVal___, const char *file, const char *opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_HCache_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_HCache_open_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, file, opt);
		}
	}
	return retVal___;
}
/* atcommand_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.init(minimal);
	}
	if( HPMHooks.count.HP_atcommand_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.final();
	}
	if( HPMHooks.count.HP_atcommand_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_atcommand_exec(const int fd, struct map_session_data *sd, const char *message, bool player_invoked) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.exec(fd, sd, message, player_invoked);
	}
	if( HPMHooks.count.HP_atcommand_exec_post ) {
		bool (*postHookFunc) (bool retVal___, const int fd, struct map_session_data *sd, const char *message, bool player_invoked);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exec_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_exec_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd, sd, message, player_invoked);
		}
	}
	return retVal___;
}
bool HP_atcommand_create(char *name, AtCommandFunc func) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.create(name, func);
	}
	if( HPMHooks.count.HP_atcommand_create_post ) {
		bool (*postHookFunc) (bool retVal___, char *name, AtCommandFunc func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, func);
		}
	}
	return retVal___;
}
bool HP_atcommand_can_use(struct map_session_data *sd, const char *command) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.can_use(sd, command);
	}
	if( HPMHooks.count.HP_atcommand_can_use_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *command);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_can_use_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, command);
		}
	}
	return retVal___;
}
bool HP_atcommand_can_use2(struct map_session_data *sd, const char *command, AtCommandType type) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.can_use2(sd, command, type);
	}
	if( HPMHooks.count.HP_atcommand_can_use2_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *command, AtCommandType type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_can_use2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_can_use2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, command, type);
		}
	}
	return retVal___;
}
void HP_atcommand_load_groups(GroupSettings **groups, struct config_setting_t **commands_, size_t sz) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_load_groups_pre ) {
		void (*preHookFunc) (GroupSettings ***groups, struct 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.load_groups(groups, commands_, sz);
	}
	if( HPMHooks.count.HP_atcommand_load_groups_post ) {
		void (*postHookFunc) (GroupSettings **groups, struct config_setting_t **commands_, size_t sz);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_load_groups_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_load_groups_post[hIndex].func;
			postHookFunc(groups, commands_, sz);
		}
	}
	return;
}
AtCommandInfo* HP_atcommand_exists(const char *name) {
	int hIndex = 0;
	AtCommandInfo* retVal___ = NULL;
	if( HPMHooks.count.HP_atcommand_exists_pre ) {
		AtCommandInfo* (*preHookFunc) (const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.exists(name);
	}
	if( HPMHooks.count.HP_atcommand_exists_post ) {
		AtCommandInfo* (*postHookFunc) (AtCommandInfo* retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_exists_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_exists_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
bool HP_atcommand_msg_read(const char *cfg_name, bool allow_override) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.msg_read(cfg_name, allow_override);
	}
	if( HPMHooks.count.HP_atcommand_msg_read_post ) {
		bool (*postHookFunc) (bool retVal___, const char *cfg_name, bool allow_override);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_msg_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cfg_name, allow_override);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.final_msg();
	}
	if( HPMHooks.count.HP_atcommand_final_msg_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_final_msg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_final_msg_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct atcmd_binding_data* HP_atcommand_get_bind_byname(const char *name) {
	int hIndex = 0;
	struct atcmd_binding_data* retVal___ = NULL;
	if( HPMHooks.count.HP_atcommand_get_bind_byname_pre ) {
		struct atcmd_binding_data* (*preHookFunc) (const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.get_bind_byname(name);
	}
	if( HPMHooks.count.HP_atcommand_get_bind_byname_post ) {
		struct atcmd_binding_data* (*postHookFunc) (struct atcmd_binding_data* retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_bind_byname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_get_bind_byname_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
AtCommandInfo* HP_atcommand_get_info_byname(const char *name) {
	int hIndex = 0;
	AtCommandInfo* retVal___ = NULL;
	if( HPMHooks.count.HP_atcommand_get_info_byname_pre ) {
		AtCommandInfo* (*preHookFunc) (const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.get_info_byname(name);
	}
	if( HPMHooks.count.HP_atcommand_get_info_byname_post ) {
		AtCommandInfo* (*postHookFunc) (AtCommandInfo* retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_info_byname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_get_info_byname_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
const char* HP_atcommand_check_alias(const char *aliasname) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_atcommand_check_alias_pre ) {
		const char* (*preHookFunc) (const char **aliasname);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.check_alias(aliasname);
	}
	if( HPMHooks.count.HP_atcommand_check_alias_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *aliasname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_check_alias_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_check_alias_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, aliasname);
		}
	}
	return retVal___;
}
void HP_atcommand_get_suggestions(struct map_session_data *sd, const char *name, bool is_atcmd_cmd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_get_suggestions_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **name, bool *is_atcmd_cmd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.get_suggestions(sd, name, is_atcmd_cmd);
	}
	if( HPMHooks.count.HP_atcommand_get_suggestions_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *name, bool is_atcmd_cmd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_suggestions_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_get_suggestions_post[hIndex].func;
			postHookFunc(sd, name, is_atcmd_cmd);
		}
	}
	return;
}
void HP_atcommand_config_read(const char *config_filename) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_config_read_pre ) {
		void (*preHookFunc) (const char **config_filename);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.config_read(config_filename);
	}
	if( HPMHooks.count.HP_atcommand_config_read_post ) {
		void (*postHookFunc) (const char *config_filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_config_read_post[hIndex].func;
			postHookFunc(config_filename);
		}
	}
	return;
}
int HP_atcommand_stopattack(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.atcommand.stopattack(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_atcommand_stopattack_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_stopattack_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_atcommand_stopattack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_atcommand_pvpoff_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.atcommand.pvpoff_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_atcommand_pvpoff_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_pvpoff_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_atcommand_pvpoff_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_atcommand_pvpon_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.atcommand.pvpon_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_atcommand_pvpon_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_pvpon_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_atcommand_pvpon_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_atcommand_atkillmonster_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.atcommand.atkillmonster_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_atcommand_atkillmonster_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_atkillmonster_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_atcommand_atkillmonster_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_atcommand_raise_sub(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_raise_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.raise_sub(sd);
	}
	if( HPMHooks.count.HP_atcommand_raise_sub_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_raise_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_raise_sub_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_atcommand_get_jail_time(int jailtime, int *year, int *month, int *day, int *hour, int *minute) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_get_jail_time_pre ) {
		void (*preHookFunc) (int *jailtime, int **year, int **month, int **day, int **hour, int **minute);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.get_jail_time(jailtime, year, month, day, hour, minute);
	}
	if( HPMHooks.count.HP_atcommand_get_jail_time_post ) {
		void (*postHookFunc) (int jailtime, int *year, int *month, int *day, int *hour, int *minute);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_get_jail_time_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_get_jail_time_post[hIndex].func;
			postHookFunc(jailtime, year, month, day, hour, minute);
		}
	}
	return;
}
int HP_atcommand_cleanfloor_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.atcommand.cleanfloor_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_atcommand_cleanfloor_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cleanfloor_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_atcommand_cleanfloor_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_atcommand_mutearea_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.atcommand.mutearea_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_atcommand_mutearea_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_mutearea_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_atcommand_mutearea_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_atcommand_getring(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_getring_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_getring_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_atcommand_getring_pre[hIndex].func;
			preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.getring(sd);
	}
	if( HPMHooks.count.HP_atcommand_getring_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_getring_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_getring_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_atcommand_channel_help(int fd, const char *command, bool can_create) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_channel_help_pre ) {
		void (*preHookFunc) (int *fd, const char **command, bool *can_create);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_channel_help_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_atcommand_channel_help_pre[hIndex].func;
			preHookFunc(&fd, &command, &can_create);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.channel_help(fd, command, can_create);
	}
	if( HPMHooks.count.HP_atcommand_channel_help_post ) {
		void (*postHookFunc) (int fd, const char *command, bool can_create);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_channel_help_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_channel_help_post[hIndex].func;
			postHookFunc(fd, command, can_create);
		}
	}
	return;
}
void HP_atcommand_commands_sub(struct map_session_data *sd, const int fd, AtCommandType type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_commands_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const int *fd, AtCommandType *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.commands_sub(sd, fd, type);
	}
	if( HPMHooks.count.HP_atcommand_commands_sub_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const int fd, AtCommandType type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_commands_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_commands_sub_post[hIndex].func;
			postHookFunc(sd, fd, type);
		}
	}
	return;
}
void HP_atcommand_cmd_db_clear(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_cmd_db_clear_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.cmd_db_clear();
	}
	if( HPMHooks.count.HP_atcommand_cmd_db_clear_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cmd_db_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_cmd_db_clear_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_atcommand_cmd_db_clear_sub(union DBKey key, struct DBData *data, va_list args) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_atcommand_cmd_db_clear_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.atcommand.cmd_db_clear_sub(key, data, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_atcommand_cmd_db_clear_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_cmd_db_clear_sub_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_atcommand_cmd_db_clear_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
void HP_atcommand_doload(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_doload_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_doload_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_atcommand_doload_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.doload();
	}
	if( HPMHooks.count.HP_atcommand_doload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_doload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_doload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_atcommand_base_commands(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_base_commands_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.base_commands();
	}
	if( HPMHooks.count.HP_atcommand_base_commands_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_base_commands_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_base_commands_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_atcommand_add(char *name, AtCommandFunc func, bool replace) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.add(name, func, replace);
	}
	if( HPMHooks.count.HP_atcommand_add_post ) {
		bool (*postHookFunc) (bool retVal___, char *name, AtCommandFunc func, bool replace);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_add_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, func, replace);
		}
	}
	return retVal___;
}
const char* HP_atcommand_msg(int msg_number) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.msg(msg_number);
	}
	if( HPMHooks.count.HP_atcommand_msg_post ) {
		const char* (*postHookFunc) (const char* retVal___, int msg_number);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_msg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, msg_number);
		}
	}
	return retVal___;
}
void HP_atcommand_expand_message_table(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_atcommand_expand_message_table_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_expand_message_table_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_atcommand_expand_message_table_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.atcommand.expand_message_table();
	}
	if( HPMHooks.count.HP_atcommand_expand_message_table_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_expand_message_table_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_expand_message_table_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
const char* HP_atcommand_msgfd(int fd, int msg_number) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_atcommand_msgfd_pre ) {
		const char* (*preHookFunc) (int *fd, int *msg_number);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msgfd_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_atcommand_msgfd_pre[hIndex].func;
			retVal___ = preHookFunc(&fd, &msg_number);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.msgfd(fd, msg_number);
	}
	if( HPMHooks.count.HP_atcommand_msgfd_post ) {
		const char* (*postHookFunc) (const char* retVal___, int fd, int msg_number);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msgfd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_msgfd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd, msg_number);
		}
	}
	return retVal___;
}
const char* HP_atcommand_msgsd(struct map_session_data *sd, int msg_number) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_atcommand_msgsd_pre ) {
		const char* (*preHookFunc) (struct map_session_data **sd, int *msg_number);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msgsd_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_atcommand_msgsd_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &msg_number);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.atcommand.msgsd(sd, msg_number);
	}
	if( HPMHooks.count.HP_atcommand_msgsd_post ) {
		const char* (*postHookFunc) (const char* retVal___, struct map_session_data *sd, int msg_number);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_atcommand_msgsd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_atcommand_msgsd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, msg_number);
		}
	}
	return retVal___;
}
/* battle_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.init(minimal);
	}
	if( HPMHooks.count.HP_battle_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.final();
	}
	if( HPMHooks.count.HP_battle_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct Damage HP_battle_calc_attack(int attack_type, struct block_list *bl, struct block_list *target, uint16 skill_id, uint16 skill_lv, int count) {
	int hIndex = 0;
	struct Damage retVal___ = { 0 };
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_attack(attack_type, bl, target, skill_id, skill_lv, count);
	}
	if( HPMHooks.count.HP_battle_calc_attack_post ) {
		struct Damage (*postHookFunc) (struct Damage retVal___, int attack_type, struct block_list *bl, struct block_list *target, uint16 skill_id, uint16 skill_lv, int count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_attack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, attack_type, bl, target, skill_id, skill_lv, count);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_damage(struct block_list *src, struct block_list *bl, struct Damage *d, int64 damage, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_damage(src, bl, d, damage, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_battle_calc_damage_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, struct Damage *d, int64 damage, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, d, damage, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_pc_damage(struct block_list *src, struct block_list *bl, struct Damage *d, int64 damage, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int64 retVal___ = 0;
	if( HPMHooks.count.HP_battle_calc_pc_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_pc_damage_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_battle_calc_pc_damage_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &bl, &d, &damage, &skill_id, &skill_lv);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_pc_damage(src, bl, d, damage, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_battle_calc_pc_damage_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, struct Damage *d, int64 damage, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_pc_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_pc_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, d, damage, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_gvg_damage(struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_gvg_damage(src, bl, damage, div_, skill_id, skill_lv, flag);
	}
	if( HPMHooks.count.HP_battle_calc_gvg_damage_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_gvg_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_gvg_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, damage, div_, skill_id, skill_lv, flag);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_bg_damage(struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_bg_damage(src, bl, damage, div_, skill_id, skill_lv, flag);
	}
	if( HPMHooks.count.HP_battle_calc_bg_damage_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int div_, uint16 skill_id, uint16 skill_lv, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_bg_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_bg_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, damage, div_, skill_id, skill_lv, flag);
		}
	}
	return retVal___;
}
enum damage_lv HP_battle_weapon_attack(struct block_list *bl, struct block_list *target, int64 tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.weapon_attack(bl, target, tick, flag);
	}
	if( HPMHooks.count.HP_battle_weapon_attack_post ) {
		enum damage_lv (*postHookFunc) (enum damage_lv retVal___, struct block_list *bl, struct block_list *target, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_weapon_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_weapon_attack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, target, tick, flag);
		}
	}
	return retVal___;
}
bool HP_battle_check_arrows(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_battle_check_arrows_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_arrows_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_battle_check_arrows_pre[hIndex].func;
			retVal___ = preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.check_arrows(sd);
	}
	if( HPMHooks.count.HP_battle_check_arrows_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_arrows_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_check_arrows_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
struct Damage HP_battle_calc_weapon_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int wflag) {
	int hIndex = 0;
	struct Damage retVal___ = { 0 };
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_weapon_attack(src, target, skill_id, skill_lv, wflag);
	}
	if( HPMHooks.count.HP_battle_calc_weapon_attack_post ) {
		struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int wflag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_weapon_attack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, wflag);
		}
	}
	return retVal___;
}
int HP_battle_delay_damage(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) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.delay_damage(tick, amotion, src, target, attack_type, skill_id, skill_lv, damage, dmg_lv, ddelay, additional_effects);
	}
	if( HPMHooks.count.HP_battle_delay_damage_post ) {
		int (*postHookFunc) (int retVal___, 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);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_delay_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tick, amotion, src, target, attack_type, skill_id, skill_lv, damage, dmg_lv, ddelay, additional_effects);
		}
	}
	return retVal___;
}
void HP_battle_drain(struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss) {
	int hIndex = 0;
	if( HPMHooks.count.HP_battle_drain_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct block_list **tbl, int64 *rdamage, int64 *ldamage, int *race, int *boss);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.drain(sd, tbl, rdamage, ldamage, race, boss);
	}
	if( HPMHooks.count.HP_battle_drain_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct block_list *tbl, int64 rdamage, int64 ldamage, int race, int boss);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_drain_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_drain_post[hIndex].func;
			postHookFunc(sd, tbl, rdamage, ldamage, race, boss);
		}
	}
	return;
}
void HP_battle_reflect_damage(struct block_list *target, struct block_list *src, struct Damage *wd, uint16 skill_id) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.reflect_damage(target, src, wd, skill_id);
	}
	if( HPMHooks.count.HP_battle_reflect_damage_post ) {
		void (*postHookFunc) (struct block_list *target, struct block_list *src, struct Damage *wd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_reflect_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_reflect_damage_post[hIndex].func;
			postHookFunc(target, src, wd, skill_id);
		}
	}
	return;
}
int HP_battle_attr_ratio(int atk_elem, int def_type, int def_lv) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.attr_ratio(atk_elem, def_type, def_lv);
	}
	if( HPMHooks.count.HP_battle_attr_ratio_post ) {
		int (*postHookFunc) (int retVal___, int atk_elem, int def_type, int def_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_ratio_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_attr_ratio_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, atk_elem, def_type, def_lv);
		}
	}
	return retVal___;
}
int64 HP_battle_attr_fix(struct block_list *src, struct block_list *target, int64 damage, int atk_elem, int def_type, int def_lv) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.attr_fix(src, target, damage, atk_elem, def_type, def_lv);
	}
	if( HPMHooks.count.HP_battle_attr_fix_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, int64 damage, int atk_elem, int def_type, int def_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_attr_fix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_attr_fix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, damage, atk_elem, def_type, def_lv);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_cardfix(int attack_type, struct block_list *src, struct block_list *target, int nk, int s_ele, int s_ele_, int64 damage, int left, int flag) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_cardfix(attack_type, src, target, nk, s_ele, s_ele_, damage, left, flag);
	}
	if( HPMHooks.count.HP_battle_calc_cardfix_post ) {
		int64 (*postHookFunc) (int64 retVal___, int attack_type, struct block_list *src, struct block_list *target, int nk, int s_ele, int s_ele_, int64 damage, int left, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_cardfix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, attack_type, src, target, nk, s_ele, s_ele_, damage, left, flag);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_cardfix2(struct block_list *src, struct block_list *bl, int64 damage, int s_ele, int nk, int flag) {
	int hIndex = 0;
	int64 retVal___ = 0;
	if( HPMHooks.count.HP_battle_calc_cardfix2_pre ) {
		int64 (*preHookFunc) (struct block_list **src, struct block_list **bl, int64 *damage, int *s_ele, int *nk, int *flag);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix2_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_battle_calc_cardfix2_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &bl, &damage, &s_ele, &nk, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_cardfix2(src, bl, damage, s_ele, nk, flag);
	}
	if( HPMHooks.count.HP_battle_calc_cardfix2_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, int64 damage, int s_ele, int nk, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_cardfix2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_cardfix2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, damage, s_ele, nk, flag);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_elefix(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int nk, int n_ele, int s_ele, int s_ele_, bool left, int flag) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_elefix(src, target, skill_id, skill_lv, damage, nk, n_ele, s_ele, s_ele_, left, flag);
	}
	if( HPMHooks.count.HP_battle_calc_elefix_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int nk, int n_ele, int s_ele, int s_ele_, bool left, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_elefix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_elefix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, damage, nk, n_ele, s_ele, s_ele_, left, flag);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_masteryfix(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int div, bool left, bool weapon) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_masteryfix(src, target, skill_id, skill_lv, damage, div, left, weapon);
	}
	if( HPMHooks.count.HP_battle_calc_masteryfix_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int div, bool left, bool weapon);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, damage, div, left, weapon);
		}
	}
	return retVal___;
}
int HP_battle_calc_chorusbonus(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_chorusbonus(sd);
	}
	if( HPMHooks.count.HP_battle_calc_chorusbonus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_chorusbonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_chorusbonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_battle_calc_skillratio(int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int skillratio, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_skillratio(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
	}
	if( HPMHooks.count.HP_battle_calc_skillratio_post ) {
		int (*postHookFunc) (int retVal___, int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int skillratio, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_skillratio_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, attack_type, src, target, skill_id, skill_lv, skillratio, flag);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_sizefix(struct map_session_data *sd, int64 damage, int type, int size, bool ignore) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_sizefix(sd, damage, type, size, ignore);
	}
	if( HPMHooks.count.HP_battle_calc_sizefix_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct map_session_data *sd, int64 damage, int type, int size, bool ignore);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_sizefix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_sizefix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, damage, type, size, ignore);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_weapon_damage(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, struct weapon_atk *watk, int nk, bool n_ele, short s_ele, short s_ele_, int size, int type, int flag, int flag2) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_weapon_damage(src, bl, skill_id, skill_lv, watk, nk, n_ele, s_ele, s_ele_, size, type, flag, flag2);
	}
	if( HPMHooks.count.HP_battle_calc_weapon_damage_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, struct weapon_atk *watk, int nk, bool n_ele, short s_ele, short s_ele_, int size, int type, int flag, int flag2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_weapon_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_weapon_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, watk, nk, n_ele, s_ele, s_ele_, size, type, flag, flag2);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_defense(int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int flag, int pdef) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_defense(attack_type, src, target, skill_id, skill_lv, damage, flag, pdef);
	}
	if( HPMHooks.count.HP_battle_calc_defense_post ) {
		int64 (*postHookFunc) (int64 retVal___, int attack_type, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 damage, int flag, int pdef);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_defense_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_defense_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, attack_type, src, target, skill_id, skill_lv, damage, flag, pdef);
		}
	}
	return retVal___;
}
struct block_list* HP_battle_get_master(struct block_list *src) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_battle_get_master_pre ) {
		struct block_list* (*preHookFunc) (struct block_list **src);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.get_master(src);
	}
	if( HPMHooks.count.HP_battle_get_master_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_master_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_get_master_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src);
		}
	}
	return retVal___;
}
struct block_list* HP_battle_get_targeted(struct block_list *target) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_battle_get_targeted_pre ) {
		struct block_list* (*preHookFunc) (struct block_list **target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.get_targeted(target);
	}
	if( HPMHooks.count.HP_battle_get_targeted_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_targeted_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_get_targeted_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, target);
		}
	}
	return retVal___;
}
struct block_list* HP_battle_get_enemy(struct block_list *target, int type, int range) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_battle_get_enemy_pre ) {
		struct block_list* (*preHookFunc) (struct block_list **target, int *type, int *range);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.get_enemy(target, type, range);
	}
	if( HPMHooks.count.HP_battle_get_enemy_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *target, int type, int range);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_get_enemy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, target, type, range);
		}
	}
	return retVal___;
}
int HP_battle_get_target(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.get_target(bl);
	}
	if( HPMHooks.count.HP_battle_get_target_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_get_target_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_battle_get_current_skill(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.get_current_skill(bl);
	}
	if( HPMHooks.count.HP_battle_get_current_skill_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_current_skill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_get_current_skill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
bool HP_battle_check_undead(int race, int element) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.check_undead(race, element);
	}
	if( HPMHooks.count.HP_battle_check_undead_post ) {
		bool (*postHookFunc) (bool retVal___, int race, int element);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_undead_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_check_undead_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, race, element);
		}
	}
	return retVal___;
}
int HP_battle_check_target(struct block_list *src, struct block_list *target, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.check_target(src, target, flag);
	}
	if( HPMHooks.count.HP_battle_check_target_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_check_target_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, flag);
		}
	}
	return retVal___;
}
bool HP_battle_check_range(struct block_list *src, struct block_list *bl, int range) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.check_range(src, bl, range);
	}
	if( HPMHooks.count.HP_battle_check_range_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, int range);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_check_range_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_check_range_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, range);
		}
	}
	return retVal___;
}
void HP_battle_consume_ammo(struct map_session_data *sd, int skill_id, int lv) {
	int hIndex = 0;
	if( HPMHooks.count.HP_battle_consume_ammo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *skill_id, int *lv);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.consume_ammo(sd, skill_id, lv);
	}
	if( HPMHooks.count.HP_battle_consume_ammo_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int skill_id, int lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_consume_ammo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_consume_ammo_post[hIndex].func;
			postHookFunc(sd, skill_id, lv);
		}
	}
	return;
}
int HP_battle_get_targeted_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.battle.get_targeted_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_battle_get_targeted_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_targeted_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_battle_get_targeted_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_battle_get_enemy_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.battle.get_enemy_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_battle_get_enemy_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_battle_get_enemy_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_battle_get_enemy_area_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.battle.get_enemy_area_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_battle_get_enemy_area_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_battle_get_enemy_area_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_battle_delay_damage_sub(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.delay_damage_sub(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_battle_delay_damage_sub_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_delay_damage_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_delay_damage_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_battle_blewcount_bonus(struct map_session_data *sd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.blewcount_bonus(sd, skill_id);
	}
	if( HPMHooks.count.HP_battle_blewcount_bonus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_blewcount_bonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_blewcount_bonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
int HP_battle_range_type(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.range_type(src, target, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_battle_range_type_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_range_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_range_type_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_base_damage(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int nk, bool n_ele, short s_ele, short s_ele_, int type, int flag, int flag2) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_base_damage(src, bl, skill_id, skill_lv, nk, n_ele, s_ele, s_ele_, type, flag, flag2);
	}
	if( HPMHooks.count.HP_battle_calc_base_damage_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int nk, bool n_ele, short s_ele, short s_ele_, int type, int flag, int flag2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_base_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, nk, n_ele, s_ele, s_ele_, type, flag, flag2);
		}
	}
	return retVal___;
}
int64 HP_battle_calc_base_damage2(struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_base_damage2(st, wa, sc, t_size, sd, flag);
	}
	if( HPMHooks.count.HP_battle_calc_base_damage2_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct status_data *st, struct weapon_atk *wa, struct status_change *sc, unsigned short t_size, struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_base_damage2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_base_damage2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, wa, sc, t_size, sd, flag);
		}
	}
	return retVal___;
}
struct Damage HP_battle_calc_misc_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag) {
	int hIndex = 0;
	struct Damage retVal___ = { 0 };
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_misc_attack(src, target, skill_id, skill_lv, mflag);
	}
	if( HPMHooks.count.HP_battle_calc_misc_attack_post ) {
		struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, mflag);
		}
	}
	return retVal___;
}
struct Damage HP_battle_calc_magic_attack(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag) {
	int hIndex = 0;
	struct Damage retVal___ = { 0 };
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_magic_attack(src, target, skill_id, skill_lv, mflag);
	}
	if( HPMHooks.count.HP_battle_calc_magic_attack_post ) {
		struct Damage (*postHookFunc) (struct Damage retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int mflag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_magic_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_magic_attack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, mflag);
		}
	}
	return retVal___;
}
int HP_battle_adjust_skill_damage(int m, unsigned short skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.adjust_skill_damage(m, skill_id);
	}
	if( HPMHooks.count.HP_battle_adjust_skill_damage_post ) {
		int (*postHookFunc) (int retVal___, int m, unsigned short skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_adjust_skill_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_adjust_skill_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, skill_id);
		}
	}
	return retVal___;
}
int64 HP_battle_add_mastery(struct map_session_data *sd, struct block_list *target, int64 dmg, int type) {
	int hIndex = 0;
	int64 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.add_mastery(sd, target, dmg, type);
	}
	if( HPMHooks.count.HP_battle_add_mastery_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct map_session_data *sd, struct block_list *target, int64 dmg, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_add_mastery_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_add_mastery_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, target, dmg, type);
		}
	}
	return retVal___;
}
int HP_battle_calc_drain(int64 damage, int rate, int per) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.calc_drain(damage, rate, per);
	}
	if( HPMHooks.count.HP_battle_calc_drain_post ) {
		int (*postHookFunc) (int retVal___, int64 damage, int rate, int per);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_drain_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_drain_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, damage, rate, per);
		}
	}
	return retVal___;
}
int HP_battle_config_read(const char *cfgName) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.config_read(cfgName);
	}
	if( HPMHooks.count.HP_battle_config_read_post ) {
		int (*postHookFunc) (int retVal___, const char *cfgName);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_config_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cfgName);
		}
	}
	return retVal___;
}
void HP_battle_config_set_defaults(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_battle_config_set_defaults_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.config_set_defaults();
	}
	if( HPMHooks.count.HP_battle_config_set_defaults_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_set_defaults_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_config_set_defaults_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_battle_config_set_value(const char *w1, const char *w2) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.config_set_value(w1, w2);
	}
	if( HPMHooks.count.HP_battle_config_set_value_post ) {
		int (*postHookFunc) (int retVal___, const char *w1, const char *w2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_set_value_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_config_set_value_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2);
		}
	}
	return retVal___;
}
bool HP_battle_config_get_value(const char *w1, int *value) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_battle_config_get_value_pre ) {
		bool (*preHookFunc) (const char **w1, int **value);
		*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, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.config_get_value(w1, value);
	}
	if( HPMHooks.count.HP_battle_config_get_value_post ) {
		bool (*postHookFunc) (bool retVal___, const char *w1, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_get_value_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_config_get_value_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, value);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.config_adjust();
	}
	if( HPMHooks.count.HP_battle_config_adjust_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_config_adjust_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_config_adjust_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct block_list* HP_battle_get_enemy_area(struct block_list *src, int x, int y, int range, int type, int ignore_id) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_battle_get_enemy_area_pre ) {
		struct block_list* (*preHookFunc) (struct block_list **src, int *x, int *y, int *range, int *type, int *ignore_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.battle.get_enemy_area(src, x, y, range, type, ignore_id);
	}
	if( HPMHooks.count.HP_battle_get_enemy_area_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct block_list *src, int x, int y, int range, int type, int ignore_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_get_enemy_area_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_get_enemy_area_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, x, y, range, type, ignore_id);
		}
	}
	return retVal___;
}
int HP_battle_damage_area(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.battle.damage_area(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_battle_damage_area_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_damage_area_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_battle_damage_area_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_battle_calc_masteryfix_unknown(struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon) {
	int hIndex = 0;
	if( HPMHooks.count.HP_battle_calc_masteryfix_unknown_pre ) {
		void (*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_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_unknown_pre[hIndex].func;
			preHookFunc(&src, &target, &skill_id, &skill_lv, &damage, &div, &left, &weapon);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.calc_masteryfix_unknown(src, target, skill_id, skill_lv, damage, div, left, weapon);
	}
	if( HPMHooks.count.HP_battle_calc_masteryfix_unknown_post ) {
		void (*postHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int64 *damage, int *div, bool *left, bool *weapon);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_masteryfix_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_masteryfix_unknown_post[hIndex].func;
			postHookFunc(src, target, skill_id, skill_lv, damage, div, left, weapon);
		}
	}
	return;
}
void HP_battle_calc_skillratio_magic_unknown(int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_pre ) {
		void (*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_magic_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_battle_calc_skillratio_magic_unknown_pre[hIndex].func;
			preHookFunc(&attack_type, &src, &target, &skill_id, &skill_lv, &skillratio, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.calc_skillratio_magic_unknown(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
	}
	if( HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_post ) {
		void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_magic_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_skillratio_magic_unknown_post[hIndex].func;
			postHookFunc(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
		}
	}
	return;
}
void HP_battle_calc_skillratio_weapon_unknown(int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_pre ) {
		void (*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_weapon_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_battle_calc_skillratio_weapon_unknown_pre[hIndex].func;
			preHookFunc(&attack_type, &src, &target, &skill_id, &skill_lv, &skillratio, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.calc_skillratio_weapon_unknown(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
	}
	if( HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_post ) {
		void (*postHookFunc) (int *attack_type, struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *skillratio, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_skillratio_weapon_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_skillratio_weapon_unknown_post[hIndex].func;
			postHookFunc(attack_type, src, target, skill_id, skill_lv, skillratio, flag);
		}
	}
	return;
}
void HP_battle_calc_misc_attack_unknown(struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md) {
	int hIndex = 0;
	if( HPMHooks.count.HP_battle_calc_misc_attack_unknown_pre ) {
		void (*preHookFunc) (struct block_list **src, struct block_list **target, uint16 **skill_id, uint16 **skill_lv, int **mflag, struct Damage **md);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_unknown_pre[hIndex].func;
			preHookFunc(&src, &target, &skill_id, &skill_lv, &mflag, &md);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.battle.calc_misc_attack_unknown(src, target, skill_id, skill_lv, mflag, md);
	}
	if( HPMHooks.count.HP_battle_calc_misc_attack_unknown_post ) {
		void (*postHookFunc) (struct block_list *src, struct block_list *target, uint16 *skill_id, uint16 *skill_lv, int *mflag, struct Damage *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_battle_calc_misc_attack_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_battle_calc_misc_attack_unknown_post[hIndex].func;
			postHookFunc(src, target, skill_id, skill_lv, mflag, md);
		}
	}
	return;
}
/* battleground_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.init(minimal);
	}
	if( HPMHooks.count.HP_bg_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.final();
	}
	if( HPMHooks.count.HP_bg_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct bg_arena* HP_bg_name2arena(const char *name) {
	int hIndex = 0;
	struct bg_arena* retVal___ = NULL;
	if( HPMHooks.count.HP_bg_name2arena_pre ) {
		struct bg_arena* (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.name2arena(name);
	}
	if( HPMHooks.count.HP_bg_name2arena_post ) {
		struct bg_arena* (*postHookFunc) (struct bg_arena* retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_name2arena_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_name2arena_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
void HP_bg_queue_add(struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_bg_queue_add_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct bg_arena **arena, enum bg_queue_types *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.queue_add(sd, arena, type);
	}
	if( HPMHooks.count.HP_bg_queue_add_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_queue_add_post[hIndex].func;
			postHookFunc(sd, arena, type);
		}
	}
	return;
}
enum BATTLEGROUNDS_QUEUE_ACK HP_bg_can_queue(struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type) {
	int hIndex = 0;
	enum BATTLEGROUNDS_QUEUE_ACK retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.can_queue(sd, arena, type);
	}
	if( HPMHooks.count.HP_bg_can_queue_post ) {
		enum BATTLEGROUNDS_QUEUE_ACK (*postHookFunc) (enum BATTLEGROUNDS_QUEUE_ACK retVal___, struct map_session_data *sd, struct bg_arena *arena, enum bg_queue_types type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_can_queue_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_can_queue_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, arena, type);
		}
	}
	return retVal___;
}
int HP_bg_id2pos(int queue_id, int account_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.id2pos(queue_id, account_id);
	}
	if( HPMHooks.count.HP_bg_id2pos_post ) {
		int (*postHookFunc) (int retVal___, int queue_id, int account_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_id2pos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_id2pos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, queue_id, account_id);
		}
	}
	return retVal___;
}
void HP_bg_queue_pc_cleanup(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_bg_queue_pc_cleanup_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.queue_pc_cleanup(sd);
	}
	if( HPMHooks.count.HP_bg_queue_pc_cleanup_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pc_cleanup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_queue_pc_cleanup_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_bg_begin(struct bg_arena *arena) {
	int hIndex = 0;
	if( HPMHooks.count.HP_bg_begin_pre ) {
		void (*preHookFunc) (struct bg_arena **arena);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.begin(arena);
	}
	if( HPMHooks.count.HP_bg_begin_post ) {
		void (*postHookFunc) (struct bg_arena *arena);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_begin_post[hIndex].func;
			postHookFunc(arena);
		}
	}
	return;
}
int HP_bg_begin_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.begin_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_bg_begin_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_begin_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_begin_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_bg_queue_pregame(struct bg_arena *arena) {
	int hIndex = 0;
	if( HPMHooks.count.HP_bg_queue_pregame_pre ) {
		void (*preHookFunc) (struct bg_arena **arena);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.queue_pregame(arena);
	}
	if( HPMHooks.count.HP_bg_queue_pregame_post ) {
		void (*postHookFunc) (struct bg_arena *arena);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_pregame_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_queue_pregame_post[hIndex].func;
			postHookFunc(arena);
		}
	}
	return;
}
int HP_bg_fillup_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.fillup_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_bg_fillup_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_fillup_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_fillup_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_bg_queue_ready_ack(struct bg_arena *arena, struct map_session_data *sd, bool response) {
	int hIndex = 0;
	if( HPMHooks.count.HP_bg_queue_ready_ack_pre ) {
		void (*preHookFunc) (struct bg_arena **arena, struct map_session_data **sd, bool *response);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.queue_ready_ack(arena, sd, response);
	}
	if( HPMHooks.count.HP_bg_queue_ready_ack_post ) {
		void (*postHookFunc) (struct bg_arena *arena, struct map_session_data *sd, bool response);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_ready_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_queue_ready_ack_post[hIndex].func;
			postHookFunc(arena, sd, response);
		}
	}
	return;
}
void HP_bg_match_over(struct bg_arena *arena, bool canceled) {
	int hIndex = 0;
	if( HPMHooks.count.HP_bg_match_over_pre ) {
		void (*preHookFunc) (struct bg_arena **arena, bool *canceled);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.match_over(arena, canceled);
	}
	if( HPMHooks.count.HP_bg_match_over_post ) {
		void (*postHookFunc) (struct bg_arena *arena, bool canceled);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_match_over_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_match_over_post[hIndex].func;
			postHookFunc(arena, canceled);
		}
	}
	return;
}
void HP_bg_queue_check(struct bg_arena *arena) {
	int hIndex = 0;
	if( HPMHooks.count.HP_bg_queue_check_pre ) {
		void (*preHookFunc) (struct bg_arena **arena);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.queue_check(arena);
	}
	if( HPMHooks.count.HP_bg_queue_check_post ) {
		void (*postHookFunc) (struct bg_arena *arena);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_queue_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_queue_check_post[hIndex].func;
			postHookFunc(arena);
		}
	}
	return;
}
struct battleground_data* HP_bg_team_search(int bg_id) {
	int hIndex = 0;
	struct battleground_data* retVal___ = NULL;
	if( HPMHooks.count.HP_bg_team_search_pre ) {
		struct battleground_data* (*preHookFunc) (int *bg_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.team_search(bg_id);
	}
	if( HPMHooks.count.HP_bg_team_search_post ) {
		struct battleground_data* (*postHookFunc) (struct battleground_data* retVal___, int bg_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_team_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bg_id);
		}
	}
	return retVal___;
}
struct map_session_data* HP_bg_getavailablesd(struct battleground_data *bgd) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_bg_getavailablesd_pre ) {
		struct map_session_data* (*preHookFunc) (struct battleground_data **bgd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.getavailablesd(bgd);
	}
	if( HPMHooks.count.HP_bg_getavailablesd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct battleground_data *bgd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_getavailablesd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_getavailablesd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bgd);
		}
	}
	return retVal___;
}
bool HP_bg_team_delete(int bg_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.team_delete(bg_id);
	}
	if( HPMHooks.count.HP_bg_team_delete_post ) {
		bool (*postHookFunc) (bool retVal___, int bg_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_team_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bg_id);
		}
	}
	return retVal___;
}
bool HP_bg_team_warp(int bg_id, unsigned short map_index, short x, short y) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.team_warp(bg_id, map_index, x, y);
	}
	if( HPMHooks.count.HP_bg_team_warp_post ) {
		bool (*postHookFunc) (bool retVal___, int bg_id, unsigned short map_index, short x, short y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_warp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_team_warp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bg_id, map_index, x, y);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.send_dot_remove(sd);
	}
	if( HPMHooks.count.HP_bg_send_dot_remove_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_dot_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_send_dot_remove_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
bool HP_bg_team_join(int bg_id, struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.team_join(bg_id, sd);
	}
	if( HPMHooks.count.HP_bg_team_join_post ) {
		bool (*postHookFunc) (bool retVal___, int bg_id, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_join_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_team_join_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bg_id, sd);
		}
	}
	return retVal___;
}
int HP_bg_team_leave(struct map_session_data *sd, enum bg_team_leave_type flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.team_leave(sd, flag);
	}
	if( HPMHooks.count.HP_bg_team_leave_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum bg_team_leave_type flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_team_leave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, flag);
		}
	}
	return retVal___;
}
bool HP_bg_member_respawn(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.member_respawn(sd);
	}
	if( HPMHooks.count.HP_bg_member_respawn_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_member_respawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_member_respawn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_bg_create(unsigned short map_index, short rx, short ry, const char *ev, const char *dev) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.create(map_index, rx, ry, ev, dev);
	}
	if( HPMHooks.count.HP_bg_create_post ) {
		int (*postHookFunc) (int retVal___, unsigned short map_index, short rx, short ry, const char *ev, const char *dev);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, map_index, rx, ry, ev, dev);
		}
	}
	return retVal___;
}
int HP_bg_team_get_id(struct block_list *bl) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.team_get_id(bl);
	}
	if( HPMHooks.count.HP_bg_team_get_id_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_get_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_team_get_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
bool HP_bg_send_message(struct map_session_data *sd, const char *mes) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_bg_send_message_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.send_message(sd, mes);
	}
	if( HPMHooks.count.HP_bg_send_message_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_send_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, mes);
		}
	}
	return retVal___;
}
int HP_bg_send_xy_timer_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_bg_send_xy_timer_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.bg.send_xy_timer_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_bg_send_xy_timer_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_bg_send_xy_timer_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_bg_send_xy_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.send_xy_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_bg_send_xy_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_send_xy_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_send_xy_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_bg_afk_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.afk_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_bg_afk_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_afk_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_afk_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_bg_team_db_final(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_bg_team_db_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_db_final_pre; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			preHookFunc = HPMHooks.list.HP_bg_team_db_final_pre[hIndex].func;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.bg.team_db_final(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_bg_team_db_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_team_db_final_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_bg_team_db_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
enum bg_queue_types HP_bg_str2teamtype(const char *str) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.bg.str2teamtype(str);
	}
	if( HPMHooks.count.HP_bg_str2teamtype_post ) {
		enum bg_queue_types (*postHookFunc) (enum bg_queue_types retVal___, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_str2teamtype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_str2teamtype_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.bg.config_read();
	}
	if( HPMHooks.count.HP_bg_config_read_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_bg_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_bg_config_read_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* buyingstore_interface */
bool HP_buyingstore_setup(struct map_session_data *sd, unsigned char slots) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.buyingstore.setup(sd, slots);
	}
	if( HPMHooks.count.HP_buyingstore_setup_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned char slots);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_setup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_buyingstore_setup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, slots);
		}
	}
	return retVal___;
}
void HP_buyingstore_create(struct map_session_data *sd, int zenylimit, unsigned char result, const char *storename, const uint8 *itemlist, unsigned int count) {
	int hIndex = 0;
	if( HPMHooks.count.HP_buyingstore_create_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *zenylimit, unsigned char *result, const char **storename, const uint8 **itemlist, unsigned int *count);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.buyingstore.create(sd, zenylimit, result, storename, itemlist, count);
	}
	if( HPMHooks.count.HP_buyingstore_create_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int zenylimit, unsigned char result, const char *storename, const uint8 *itemlist, unsigned int count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_buyingstore_create_post[hIndex].func;
			postHookFunc(sd, zenylimit, result, storename, itemlist, count);
		}
	}
	return;
}
void HP_buyingstore_close(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_buyingstore_close_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.buyingstore.close(sd);
	}
	if( HPMHooks.count.HP_buyingstore_close_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_buyingstore_close_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_buyingstore_open(struct map_session_data *sd, int account_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_buyingstore_open_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *account_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.buyingstore.open(sd, account_id);
	}
	if( HPMHooks.count.HP_buyingstore_open_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int account_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_buyingstore_open_post[hIndex].func;
			postHookFunc(sd, account_id);
		}
	}
	return;
}
void HP_buyingstore_trade(struct map_session_data *sd, int account_id, unsigned int buyer_id, const uint8 *itemlist, unsigned int count) {
	int hIndex = 0;
	if( HPMHooks.count.HP_buyingstore_trade_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *account_id, unsigned int *buyer_id, const uint8 **itemlist, unsigned int *count);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.buyingstore.trade(sd, account_id, buyer_id, itemlist, count);
	}
	if( HPMHooks.count.HP_buyingstore_trade_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int account_id, unsigned int buyer_id, const uint8 *itemlist, unsigned int count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_trade_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_buyingstore_trade_post[hIndex].func;
			postHookFunc(sd, account_id, buyer_id, itemlist, count);
		}
	}
	return;
}
bool HP_buyingstore_search(struct map_session_data *sd, unsigned short nameid) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.buyingstore.search(sd, nameid);
	}
	if( HPMHooks.count.HP_buyingstore_search_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned short nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_buyingstore_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid);
		}
	}
	return retVal___;
}
bool HP_buyingstore_searchall(struct map_session_data *sd, const struct s_search_store_search *s) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.buyingstore.searchall(sd, s);
	}
	if( HPMHooks.count.HP_buyingstore_searchall_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const struct s_search_store_search *s);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_searchall_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_buyingstore_searchall_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, s);
		}
	}
	return retVal___;
}
unsigned int HP_buyingstore_getuid(void) {
	int hIndex = 0;
	unsigned int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.buyingstore.getuid();
	}
	if( HPMHooks.count.HP_buyingstore_getuid_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_buyingstore_getuid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_buyingstore_getuid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
/* channel_interface */
int HP_channel_init(bool minimal) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_channel_init_pre ) {
		int (*preHookFunc) (bool *minimal);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_init_pre[hIndex].func;
			retVal___ = preHookFunc(&minimal);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.channel.init(minimal);
	}
	if( HPMHooks.count.HP_channel_init_post ) {
		int (*postHookFunc) (int retVal___, bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, minimal);
		}
	}
	return retVal___;
}
void HP_channel_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.final();
	}
	if( HPMHooks.count.HP_channel_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct channel_data* HP_channel_search(const char *name, struct map_session_data *sd) {
	int hIndex = 0;
	struct channel_data* retVal___ = NULL;
	if( HPMHooks.count.HP_channel_search_pre ) {
		struct channel_data* (*preHookFunc) (const char **name, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_search_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_search_pre[hIndex].func;
			retVal___ = preHookFunc(&name, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.channel.search(name, sd);
	}
	if( HPMHooks.count.HP_channel_search_post ) {
		struct channel_data* (*postHookFunc) (struct channel_data* retVal___, const char *name, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, sd);
		}
	}
	return retVal___;
}
struct channel_data* HP_channel_create(enum channel_types type, const char *name, unsigned char color) {
	int hIndex = 0;
	struct channel_data* retVal___ = NULL;
	if( HPMHooks.count.HP_channel_create_pre ) {
		struct channel_data* (*preHookFunc) (enum channel_types *type, const char **name, unsigned char *color);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_create_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_create_pre[hIndex].func;
			retVal___ = preHookFunc(&type, &name, &color);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.channel.create(type, name, color);
	}
	if( HPMHooks.count.HP_channel_create_post ) {
		struct channel_data* (*postHookFunc) (struct channel_data* retVal___, enum channel_types type, const char *name, unsigned char color);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type, name, color);
		}
	}
	return retVal___;
}
void HP_channel_delete(struct channel_data *chan) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_delete_pre ) {
		void (*preHookFunc) (struct channel_data **chan);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_delete_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_delete_pre[hIndex].func;
			preHookFunc(&chan);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.delete(chan);
	}
	if( HPMHooks.count.HP_channel_delete_post ) {
		void (*postHookFunc) (struct channel_data *chan);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_delete_post[hIndex].func;
			postHookFunc(chan);
		}
	}
	return;
}
void HP_channel_set_password(struct channel_data *chan, const char *password) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_set_password_pre ) {
		void (*preHookFunc) (struct channel_data **chan, const char **password);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_set_password_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_set_password_pre[hIndex].func;
			preHookFunc(&chan, &password);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.set_password(chan, password);
	}
	if( HPMHooks.count.HP_channel_set_password_post ) {
		void (*postHookFunc) (struct channel_data *chan, const char *password);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_set_password_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_set_password_post[hIndex].func;
			postHookFunc(chan, password);
		}
	}
	return;
}
enum channel_operation_status HP_channel_ban(struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd) {
	int hIndex = 0;
	enum channel_operation_status retVal___ = HCS_STATUS_FAIL;
	if( HPMHooks.count.HP_channel_ban_pre ) {
		enum channel_operation_status (*preHookFunc) (struct channel_data **chan, const struct map_session_data **ssd, struct map_session_data **tsd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_ban_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_ban_pre[hIndex].func;
			retVal___ = preHookFunc(&chan, &ssd, &tsd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.channel.ban(chan, ssd, tsd);
	}
	if( HPMHooks.count.HP_channel_ban_post ) {
		enum channel_operation_status (*postHookFunc) (enum channel_operation_status retVal___, struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_ban_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_ban_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, chan, ssd, tsd);
		}
	}
	return retVal___;
}
enum channel_operation_status HP_channel_unban(struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd) {
	int hIndex = 0;
	enum channel_operation_status retVal___ = HCS_STATUS_FAIL;
	if( HPMHooks.count.HP_channel_unban_pre ) {
		enum channel_operation_status (*preHookFunc) (struct channel_data **chan, const struct map_session_data **ssd, struct map_session_data **tsd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_unban_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_unban_pre[hIndex].func;
			retVal___ = preHookFunc(&chan, &ssd, &tsd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.channel.unban(chan, ssd, tsd);
	}
	if( HPMHooks.count.HP_channel_unban_post ) {
		enum channel_operation_status (*postHookFunc) (enum channel_operation_status retVal___, struct channel_data *chan, const struct map_session_data *ssd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_unban_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_unban_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, chan, ssd, tsd);
		}
	}
	return retVal___;
}
void HP_channel_set_options(struct channel_data *chan, unsigned int options) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_set_options_pre ) {
		void (*preHookFunc) (struct channel_data **chan, unsigned int *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_set_options_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_set_options_pre[hIndex].func;
			preHookFunc(&chan, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.set_options(chan, options);
	}
	if( HPMHooks.count.HP_channel_set_options_post ) {
		void (*postHookFunc) (struct channel_data *chan, unsigned int options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_set_options_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_set_options_post[hIndex].func;
			postHookFunc(chan, options);
		}
	}
	return;
}
void HP_channel_send(struct channel_data *chan, struct map_session_data *sd, const char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_send_pre ) {
		void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd, const char **msg);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_send_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_send_pre[hIndex].func;
			preHookFunc(&chan, &sd, &msg);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.send(chan, sd, msg);
	}
	if( HPMHooks.count.HP_channel_send_post ) {
		void (*postHookFunc) (struct channel_data *chan, struct map_session_data *sd, const char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_send_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_send_post[hIndex].func;
			postHookFunc(chan, sd, msg);
		}
	}
	return;
}
void HP_channel_join_sub(struct channel_data *chan, struct map_session_data *sd, bool stealth) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_join_sub_pre ) {
		void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd, bool *stealth);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_join_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_join_sub_pre[hIndex].func;
			preHookFunc(&chan, &sd, &stealth);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.join_sub(chan, sd, stealth);
	}
	if( HPMHooks.count.HP_channel_join_sub_post ) {
		void (*postHookFunc) (struct channel_data *chan, struct map_session_data *sd, bool stealth);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_join_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_join_sub_post[hIndex].func;
			postHookFunc(chan, sd, stealth);
		}
	}
	return;
}
enum channel_operation_status HP_channel_join(struct channel_data *chan, struct map_session_data *sd, const char *password, bool silent) {
	int hIndex = 0;
	enum channel_operation_status retVal___ = HCS_STATUS_FAIL;
	if( HPMHooks.count.HP_channel_join_pre ) {
		enum channel_operation_status (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd, const char **password, bool *silent);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_join_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_join_pre[hIndex].func;
			retVal___ = preHookFunc(&chan, &sd, &password, &silent);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.channel.join(chan, sd, password, silent);
	}
	if( HPMHooks.count.HP_channel_join_post ) {
		enum channel_operation_status (*postHookFunc) (enum channel_operation_status retVal___, struct channel_data *chan, struct map_session_data *sd, const char *password, bool silent);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_join_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_join_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, chan, sd, password, silent);
		}
	}
	return retVal___;
}
void HP_channel_leave(struct channel_data *chan, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_leave_pre ) {
		void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_leave_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_leave_pre[hIndex].func;
			preHookFunc(&chan, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.leave(chan, sd);
	}
	if( HPMHooks.count.HP_channel_leave_post ) {
		void (*postHookFunc) (struct channel_data *chan, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_leave_post[hIndex].func;
			postHookFunc(chan, sd);
		}
	}
	return;
}
void HP_channel_leave_sub(struct channel_data *chan, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_leave_sub_pre ) {
		void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_leave_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_leave_sub_pre[hIndex].func;
			preHookFunc(&chan, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.leave_sub(chan, sd);
	}
	if( HPMHooks.count.HP_channel_leave_sub_post ) {
		void (*postHookFunc) (struct channel_data *chan, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_leave_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_leave_sub_post[hIndex].func;
			postHookFunc(chan, sd);
		}
	}
	return;
}
void HP_channel_quit(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_quit_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_quit_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_quit_pre[hIndex].func;
			preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.quit(sd);
	}
	if( HPMHooks.count.HP_channel_quit_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_quit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_quit_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_channel_map_join(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_map_join_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_map_join_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_map_join_pre[hIndex].func;
			preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.map_join(sd);
	}
	if( HPMHooks.count.HP_channel_map_join_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_map_join_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_map_join_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_channel_guild_join_alliance(const struct guild *g_source, const struct guild *g_ally) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_guild_join_alliance_pre ) {
		void (*preHookFunc) (const struct guild **g_source, const struct guild **g_ally);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_guild_join_alliance_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_guild_join_alliance_pre[hIndex].func;
			preHookFunc(&g_source, &g_ally);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.guild_join_alliance(g_source, g_ally);
	}
	if( HPMHooks.count.HP_channel_guild_join_alliance_post ) {
		void (*postHookFunc) (const struct guild *g_source, const struct guild *g_ally);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_guild_join_alliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_guild_join_alliance_post[hIndex].func;
			postHookFunc(g_source, g_ally);
		}
	}
	return;
}
void HP_channel_guild_leave_alliance(const struct guild *g_source, const struct guild *g_ally) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_guild_leave_alliance_pre ) {
		void (*preHookFunc) (const struct guild **g_source, const struct guild **g_ally);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_guild_leave_alliance_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_guild_leave_alliance_pre[hIndex].func;
			preHookFunc(&g_source, &g_ally);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.guild_leave_alliance(g_source, g_ally);
	}
	if( HPMHooks.count.HP_channel_guild_leave_alliance_post ) {
		void (*postHookFunc) (const struct guild *g_source, const struct guild *g_ally);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_guild_leave_alliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_guild_leave_alliance_post[hIndex].func;
			postHookFunc(g_source, g_ally);
		}
	}
	return;
}
void HP_channel_quit_guild(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_quit_guild_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_quit_guild_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_quit_guild_pre[hIndex].func;
			preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.quit_guild(sd);
	}
	if( HPMHooks.count.HP_channel_quit_guild_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_quit_guild_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_quit_guild_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_channel_irc_join(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_irc_join_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_irc_join_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_irc_join_pre[hIndex].func;
			preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.irc_join(sd);
	}
	if( HPMHooks.count.HP_channel_irc_join_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_irc_join_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_irc_join_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_channel_config_read(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_channel_config_read_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_config_read_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_channel_config_read_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.channel.config_read();
	}
	if( HPMHooks.count.HP_channel_config_read_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_channel_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_channel_config_read_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* chat_interface */
bool HP_chat_create_pc_chat(struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.create_pc_chat(sd, title, pass, limit, pub);
	}
	if( HPMHooks.count.HP_chat_create_pc_chat_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_pc_chat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_create_pc_chat_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, title, pass, limit, pub);
		}
	}
	return retVal___;
}
bool HP_chat_join(struct map_session_data *sd, int chatid, const char *pass) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.join(sd, chatid, pass);
	}
	if( HPMHooks.count.HP_chat_join_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int chatid, const char *pass);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_join_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_join_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, chatid, pass);
		}
	}
	return retVal___;
}
int HP_chat_leave(struct map_session_data *sd, bool kicked) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.leave(sd, kicked);
	}
	if( HPMHooks.count.HP_chat_leave_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool kicked);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_leave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, kicked);
		}
	}
	return retVal___;
}
bool HP_chat_change_owner(struct map_session_data *sd, const char *nextownername) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.change_owner(sd, nextownername);
	}
	if( HPMHooks.count.HP_chat_change_owner_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *nextownername);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_owner_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_change_owner_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nextownername);
		}
	}
	return retVal___;
}
bool HP_chat_change_status(struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.change_status(sd, title, pass, limit, pub);
	}
	if( HPMHooks.count.HP_chat_change_status_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *title, const char *pass, int limit, bool pub);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_change_status_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_change_status_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, title, pass, limit, pub);
		}
	}
	return retVal___;
}
bool HP_chat_kick(struct map_session_data *sd, const char *kickusername) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.kick(sd, kickusername);
	}
	if( HPMHooks.count.HP_chat_kick_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *kickusername);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_kick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_kick_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, kickusername);
		}
	}
	return retVal___;
}
bool HP_chat_create_npc_chat(struct npc_data *nd, const char *title, int limit, bool pub, int trigger, const char *ev, int zeny, int min_level, int max_level) {
	int hIndex = 0;
	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 *min_level, int *max_level);
		*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, &min_level, &max_level);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.create_npc_chat(nd, title, limit, pub, trigger, ev, zeny, min_level, max_level);
	}
	if( HPMHooks.count.HP_chat_create_npc_chat_post ) {
		bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const char *title, int limit, bool pub, int trigger, const char *ev, int zeny, int min_level, int max_level);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_npc_chat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_create_npc_chat_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, title, limit, pub, trigger, ev, zeny, min_level, max_level);
		}
	}
	return retVal___;
}
bool HP_chat_delete_npc_chat(struct npc_data *nd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.delete_npc_chat(nd);
	}
	if( HPMHooks.count.HP_chat_delete_npc_chat_post ) {
		bool (*postHookFunc) (bool retVal___, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_delete_npc_chat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_delete_npc_chat_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd);
		}
	}
	return retVal___;
}
bool HP_chat_enable_event(struct chat_data *cd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.enable_event(cd);
	}
	if( HPMHooks.count.HP_chat_enable_event_post ) {
		bool (*postHookFunc) (bool retVal___, struct chat_data *cd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_enable_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_enable_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cd);
		}
	}
	return retVal___;
}
bool HP_chat_disable_event(struct chat_data *cd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.disable_event(cd);
	}
	if( HPMHooks.count.HP_chat_disable_event_post ) {
		bool (*postHookFunc) (bool retVal___, struct chat_data *cd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_disable_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_disable_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cd);
		}
	}
	return retVal___;
}
bool HP_chat_npc_kick_all(struct chat_data *cd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.npc_kick_all(cd);
	}
	if( HPMHooks.count.HP_chat_npc_kick_all_post ) {
		bool (*postHookFunc) (bool retVal___, struct chat_data *cd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_npc_kick_all_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_npc_kick_all_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cd);
		}
	}
	return retVal___;
}
bool HP_chat_trigger_event(struct chat_data *cd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.trigger_event(cd);
	}
	if( HPMHooks.count.HP_chat_trigger_event_post ) {
		bool (*postHookFunc) (bool retVal___, struct chat_data *cd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_trigger_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_trigger_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cd);
		}
	}
	return retVal___;
}
struct chat_data* HP_chat_create(struct block_list *bl, const char *title, const char *pass, int limit, bool pub, int trigger, const char *ev, int zeny, int min_level, int max_level) {
	int hIndex = 0;
	struct chat_data* retVal___ = NULL;
	if( HPMHooks.count.HP_chat_create_pre ) {
		struct chat_data* (*preHookFunc) (struct block_list **bl, const char **title, const char **pass, int *limit, bool *pub, int *trigger, const char **ev, int *zeny, int *min_level, int *max_level);
		*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, &min_level, &max_level);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chat.create(bl, title, pass, limit, pub, trigger, ev, zeny, min_level, max_level);
	}
	if( HPMHooks.count.HP_chat_create_post ) {
		struct chat_data* (*postHookFunc) (struct chat_data* retVal___, struct block_list *bl, const char *title, const char *pass, int limit, bool pub, int trigger, const char *ev, int zeny, int min_level, int max_level);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chat_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chat_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, title, pass, limit, pub, trigger, ev, zeny, min_level, max_level);
		}
	}
	return retVal___;
}
/* chrif_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.init(minimal);
	}
	if( HPMHooks.count.HP_chrif_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.final();
	}
	if( HPMHooks.count.HP_chrif_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.setuserid(id);
	}
	if( HPMHooks.count.HP_chrif_setuserid_post ) {
		void (*postHookFunc) (char *id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setuserid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_setuserid_post[hIndex].func;
			postHookFunc(id);
		}
	}
	return;
}
void HP_chrif_setpasswd(char *pwd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_setpasswd_pre ) {
		void (*preHookFunc) (char **pwd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.setpasswd(pwd);
	}
	if( HPMHooks.count.HP_chrif_setpasswd_post ) {
		void (*postHookFunc) (char *pwd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setpasswd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_setpasswd_post[hIndex].func;
			postHookFunc(pwd);
		}
	}
	return;
}
void HP_chrif_checkdefaultlogin(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_checkdefaultlogin_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_checkdefaultlogin_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_chrif_checkdefaultlogin_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.checkdefaultlogin();
	}
	if( HPMHooks.count.HP_chrif_checkdefaultlogin_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_checkdefaultlogin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_checkdefaultlogin_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_chrif_setip(const char *ip) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.setip(ip);
	}
	if( HPMHooks.count.HP_chrif_setip_post ) {
		bool (*postHookFunc) (bool retVal___, const char *ip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_setip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip);
		}
	}
	return retVal___;
}
void HP_chrif_setport(uint16 port) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_setport_pre ) {
		void (*preHookFunc) (uint16 *port);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.setport(port);
	}
	if( HPMHooks.count.HP_chrif_setport_post ) {
		void (*postHookFunc) (uint16 port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_setport_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_setport_post[hIndex].func;
			postHookFunc(port);
		}
	}
	return;
}
int HP_chrif_isconnected(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.isconnected();
	}
	if( HPMHooks.count.HP_chrif_isconnected_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_isconnected_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_isconnected_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_chrif_check_shutdown(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_check_shutdown_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.check_shutdown();
	}
	if( HPMHooks.count.HP_chrif_check_shutdown_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_check_shutdown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_check_shutdown_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct auth_node* HP_chrif_search(int account_id) {
	int hIndex = 0;
	struct auth_node* retVal___ = NULL;
	if( HPMHooks.count.HP_chrif_search_pre ) {
		struct auth_node* (*preHookFunc) (int *account_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.search(account_id);
	}
	if( HPMHooks.count.HP_chrif_search_post ) {
		struct auth_node* (*postHookFunc) (struct auth_node* retVal___, int account_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id);
		}
	}
	return retVal___;
}
struct auth_node* HP_chrif_auth_check(int account_id, int char_id, enum sd_state state) {
	int hIndex = 0;
	struct auth_node* retVal___ = NULL;
	if( HPMHooks.count.HP_chrif_auth_check_pre ) {
		struct auth_node* (*preHookFunc) (int *account_id, int *char_id, enum sd_state *state);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.auth_check(account_id, char_id, state);
	}
	if( HPMHooks.count.HP_chrif_auth_check_post ) {
		struct auth_node* (*postHookFunc) (struct auth_node* retVal___, int account_id, int char_id, enum sd_state state);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_auth_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, char_id, state);
		}
	}
	return retVal___;
}
bool HP_chrif_auth_delete(int account_id, int char_id, enum sd_state state) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.auth_delete(account_id, char_id, state);
	}
	if( HPMHooks.count.HP_chrif_auth_delete_post ) {
		bool (*postHookFunc) (bool retVal___, int account_id, int char_id, enum sd_state state);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_auth_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, char_id, state);
		}
	}
	return retVal___;
}
bool HP_chrif_auth_finished(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.auth_finished(sd);
	}
	if( HPMHooks.count.HP_chrif_auth_finished_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_finished_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_auth_finished_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_chrif_authreq(struct map_session_data *sd, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.authreq(sd, hstandalone);
	}
	if( HPMHooks.count.HP_chrif_authreq_post ) {
		void (*postHookFunc) (struct map_session_data *sd, bool hstandalone);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authreq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_authreq_post[hIndex].func;
			postHookFunc(sd, hstandalone);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.authok(fd);
	}
	if( HPMHooks.count.HP_chrif_authok_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_authok_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
bool HP_chrif_scdata_request(int account_id, int char_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.scdata_request(account_id, char_id);
	}
	if( HPMHooks.count.HP_chrif_scdata_request_post ) {
		bool (*postHookFunc) (bool retVal___, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_scdata_request_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_scdata_request_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, char_id);
		}
	}
	return retVal___;
}
bool HP_chrif_save(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.save(sd, flag);
	}
	if( HPMHooks.count.HP_chrif_save_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_save_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, flag);
		}
	}
	return retVal___;
}
bool HP_chrif_charselectreq(struct map_session_data *sd, uint32 s_ip) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.charselectreq(sd, s_ip);
	}
	if( HPMHooks.count.HP_chrif_charselectreq_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, uint32 s_ip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_charselectreq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_charselectreq_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, s_ip);
		}
	}
	return retVal___;
}
bool HP_chrif_changemapserver(struct map_session_data *sd, uint32 ip, uint16 port) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.changemapserver(sd, ip, port);
	}
	if( HPMHooks.count.HP_chrif_changemapserver_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, uint32 ip, uint16 port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserver_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_changemapserver_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ip, port);
		}
	}
	return retVal___;
}
bool HP_chrif_searchcharid(int char_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.searchcharid(char_id);
	}
	if( HPMHooks.count.HP_chrif_searchcharid_post ) {
		bool (*postHookFunc) (bool retVal___, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_searchcharid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_searchcharid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id);
		}
	}
	return retVal___;
}
bool HP_chrif_changeemail(int id, const char *actual_email, const char *new_email) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.changeemail(id, actual_email, new_email);
	}
	if( HPMHooks.count.HP_chrif_changeemail_post ) {
		bool (*postHookFunc) (bool retVal___, int id, const char *actual_email, const char *new_email);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changeemail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_changeemail_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id, actual_email, new_email);
		}
	}
	return retVal___;
}
bool HP_chrif_char_ask_name(int acc, const char *character_name, unsigned short operation_type, int year, int month, int day, int hour, int minute, int second) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.char_ask_name(acc, character_name, operation_type, year, month, day, hour, minute, second);
	}
	if( HPMHooks.count.HP_chrif_char_ask_name_post ) {
		bool (*postHookFunc) (bool retVal___, int acc, const char *character_name, unsigned short operation_type, int year, int month, int day, int hour, int minute, int second);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_char_ask_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, acc, character_name, operation_type, year, month, day, hour, minute, second);
		}
	}
	return retVal___;
}
int HP_chrif_updatefamelist(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.updatefamelist(sd);
	}
	if( HPMHooks.count.HP_chrif_updatefamelist_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_updatefamelist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
bool HP_chrif_buildfamelist(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.buildfamelist();
	}
	if( HPMHooks.count.HP_chrif_buildfamelist_post ) {
		bool (*postHookFunc) (bool retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_buildfamelist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_buildfamelist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_chrif_save_scdata(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.save_scdata(sd);
	}
	if( HPMHooks.count.HP_chrif_save_scdata_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_scdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_save_scdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
bool HP_chrif_ragsrvinfo(int base_rate, int job_rate, int drop_rate) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.ragsrvinfo(base_rate, job_rate, drop_rate);
	}
	if( HPMHooks.count.HP_chrif_ragsrvinfo_post ) {
		bool (*postHookFunc) (bool retVal___, int base_rate, int job_rate, int drop_rate);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_ragsrvinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_ragsrvinfo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, base_rate, job_rate, drop_rate);
		}
	}
	return retVal___;
}
bool HP_chrif_char_offline_nsd(int account_id, int char_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.char_offline_nsd(account_id, char_id);
	}
	if( HPMHooks.count.HP_chrif_char_offline_nsd_post ) {
		bool (*postHookFunc) (bool retVal___, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_offline_nsd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_char_offline_nsd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, char_id);
		}
	}
	return retVal___;
}
bool HP_chrif_char_reset_offline(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.char_reset_offline();
	}
	if( HPMHooks.count.HP_chrif_char_reset_offline_post ) {
		bool (*postHookFunc) (bool retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_reset_offline_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_char_reset_offline_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_chrif_send_users_tochar(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.send_users_tochar();
	}
	if( HPMHooks.count.HP_chrif_send_users_tochar_post ) {
		bool (*postHookFunc) (bool retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_users_tochar_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_send_users_tochar_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_chrif_char_online(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.char_online(sd);
	}
	if( HPMHooks.count.HP_chrif_char_online_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_online_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_char_online_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
bool HP_chrif_changesex(struct map_session_data *sd, bool change_account) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_chrif_changesex_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, bool *change_account);
		*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, &change_account);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.changesex(sd, change_account);
	}
	if( HPMHooks.count.HP_chrif_changesex_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, bool change_account);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changesex_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_changesex_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, change_account);
		}
	}
	return retVal___;
}
bool HP_chrif_divorce(int partner_id1, int partner_id2) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.divorce(partner_id1, partner_id2);
	}
	if( HPMHooks.count.HP_chrif_divorce_post ) {
		bool (*postHookFunc) (bool retVal___, int partner_id1, int partner_id2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_divorce_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_divorce_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, partner_id1, partner_id2);
		}
	}
	return retVal___;
}
bool HP_chrif_removefriend(int char_id, int friend_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.removefriend(char_id, friend_id);
	}
	if( HPMHooks.count.HP_chrif_removefriend_post ) {
		bool (*postHookFunc) (bool retVal___, int char_id, int friend_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removefriend_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_removefriend_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, friend_id);
		}
	}
	return retVal___;
}
void HP_chrif_send_report(char *buf, int len) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_send_report_pre ) {
		void (*preHookFunc) (char **buf, int *len);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.send_report(buf, len);
	}
	if( HPMHooks.count.HP_chrif_send_report_post ) {
		void (*postHookFunc) (char *buf, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_report_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_send_report_post[hIndex].func;
			postHookFunc(buf, len);
		}
	}
	return;
}
bool HP_chrif_flush(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.flush();
	}
	if( HPMHooks.count.HP_chrif_flush_post ) {
		bool (*postHookFunc) (bool retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_flush_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_flush_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_chrif_skillid2idx(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_skillid2idx_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.skillid2idx(fd);
	}
	if( HPMHooks.count.HP_chrif_skillid2idx_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_skillid2idx_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_skillid2idx_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
bool HP_chrif_sd_to_auth(struct map_session_data *sd, enum sd_state state) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_chrif_sd_to_auth_pre ) {
		bool (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.sd_to_auth(sd, state);
	}
	if( HPMHooks.count.HP_chrif_sd_to_auth_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, enum sd_state state);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sd_to_auth_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_sd_to_auth_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, state);
		}
	}
	return retVal___;
}
int HP_chrif_check_connect_char_server(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.check_connect_char_server(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_chrif_check_connect_char_server_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_check_connect_char_server_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_check_connect_char_server_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
bool HP_chrif_auth_logout(struct map_session_data *sd, enum sd_state state) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_chrif_auth_logout_pre ) {
		bool (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.auth_logout(sd, state);
	}
	if( HPMHooks.count.HP_chrif_auth_logout_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, enum sd_state state);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_logout_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_auth_logout_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, state);
		}
	}
	return retVal___;
}
void HP_chrif_save_ack(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_save_ack_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.save_ack(fd);
	}
	if( HPMHooks.count.HP_chrif_save_ack_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_save_ack_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
int HP_chrif_reconnect(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_chrif_reconnect_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.chrif.reconnect(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_chrif_reconnect_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_reconnect_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_chrif_reconnect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_chrif_auth_db_cleanup_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_chrif_auth_db_cleanup_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.chrif.auth_db_cleanup_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_chrif_auth_db_cleanup_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
bool HP_chrif_char_ask_name_answer(int acc, const char *player_name, uint16 type, uint16 answer) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.char_ask_name_answer(acc, player_name, type, answer);
	}
	if( HPMHooks.count.HP_chrif_char_ask_name_answer_post ) {
		bool (*postHookFunc) (bool retVal___, int acc, const char *player_name, uint16 type, uint16 answer);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_char_ask_name_answer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_char_ask_name_answer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, acc, player_name, type, answer);
		}
	}
	return retVal___;
}
int HP_chrif_auth_db_final(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_chrif_auth_db_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.chrif.auth_db_final(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_chrif_auth_db_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_final_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_chrif_auth_db_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_chrif_send_usercount_tochar(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.send_usercount_tochar(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_chrif_send_usercount_tochar_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_send_usercount_tochar_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_send_usercount_tochar_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_chrif_auth_db_cleanup(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.auth_db_cleanup(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_chrif_auth_db_cleanup_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_auth_db_cleanup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_auth_db_cleanup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.connect(fd);
	}
	if( HPMHooks.count.HP_chrif_connect_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_connect_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.connectack(fd);
	}
	if( HPMHooks.count.HP_chrif_connectack_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_connectack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_connectack_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.sendmap(fd);
	}
	if( HPMHooks.count.HP_chrif_sendmap_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_sendmap_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.sendmapack(fd);
	}
	if( HPMHooks.count.HP_chrif_sendmapack_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_sendmapack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_sendmapack_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.recvmap(fd);
	}
	if( HPMHooks.count.HP_chrif_recvmap_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvmap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_recvmap_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
bool HP_chrif_changemapserverack(int account_id, int login_id1, int login_id2, int char_id, short map_index, short x, short y, uint32 ip, uint16 port) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.changemapserverack(account_id, login_id1, login_id2, char_id, map_index, x, y, ip, port);
	}
	if( HPMHooks.count.HP_chrif_changemapserverack_post ) {
		bool (*postHookFunc) (bool retVal___, int account_id, int login_id1, int login_id2, int char_id, short map_index, short x, short y, uint32 ip, uint16 port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changemapserverack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_changemapserverack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, login_id1, login_id2, char_id, map_index, x, y, ip, port);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.changedsex(fd);
	}
	if( HPMHooks.count.HP_chrif_changedsex_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_changedsex_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_changedsex_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
bool HP_chrif_divorceack(int char_id, int partner_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.divorceack(char_id, partner_id);
	}
	if( HPMHooks.count.HP_chrif_divorceack_post ) {
		bool (*postHookFunc) (bool retVal___, int char_id, int partner_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_divorceack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_divorceack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, partner_id);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.idbanned(fd);
	}
	if( HPMHooks.count.HP_chrif_idbanned_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_idbanned_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_idbanned_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.recvfamelist(fd);
	}
	if( HPMHooks.count.HP_chrif_recvfamelist_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_recvfamelist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_recvfamelist_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
bool HP_chrif_load_scdata(int fd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.load_scdata(fd);
	}
	if( HPMHooks.count.HP_chrif_load_scdata_post ) {
		bool (*postHookFunc) (bool retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_load_scdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_load_scdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
void HP_chrif_update_ip(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_update_ip_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.update_ip(fd);
	}
	if( HPMHooks.count.HP_chrif_update_ip_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_update_ip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_update_ip_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
int HP_chrif_disconnectplayer(int fd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.disconnectplayer(fd);
	}
	if( HPMHooks.count.HP_chrif_disconnectplayer_post ) {
		int (*postHookFunc) (int retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_disconnectplayer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_disconnectplayer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.removemap(fd);
	}
	if( HPMHooks.count.HP_chrif_removemap_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_removemap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_removemap_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
int HP_chrif_updatefamelist_ack(int fd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.updatefamelist_ack(fd);
	}
	if( HPMHooks.count.HP_chrif_updatefamelist_ack_post ) {
		int (*postHookFunc) (int retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_updatefamelist_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_updatefamelist_ack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
void HP_chrif_keepalive(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_keepalive_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.keepalive(fd);
	}
	if( HPMHooks.count.HP_chrif_keepalive_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_keepalive_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_chrif_keepalive_ack(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_keepalive_ack_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.keepalive_ack(fd);
	}
	if( HPMHooks.count.HP_chrif_keepalive_ack_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_keepalive_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_keepalive_ack_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.deadopt(father_id, mother_id, child_id);
	}
	if( HPMHooks.count.HP_chrif_deadopt_post ) {
		void (*postHookFunc) (int father_id, int mother_id, int child_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_deadopt_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_deadopt_post[hIndex].func;
			postHookFunc(father_id, mother_id, child_id);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.authfail(fd);
	}
	if( HPMHooks.count.HP_chrif_authfail_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_authfail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_authfail_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_chrif_on_ready(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_on_ready_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.on_ready();
	}
	if( HPMHooks.count.HP_chrif_on_ready_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_on_ready_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_on_ready_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_chrif_on_disconnect(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_chrif_on_disconnect_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.on_disconnect();
	}
	if( HPMHooks.count.HP_chrif_on_disconnect_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_on_disconnect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_on_disconnect_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_chrif_parse(int fd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.chrif.parse(fd);
	}
	if( HPMHooks.count.HP_chrif_parse_post ) {
		int (*postHookFunc) (int retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_parse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_parse_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
void HP_chrif_save_scdata_single(int account_id, int char_id, short type, struct status_change_entry *sce) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.save_scdata_single(account_id, char_id, type, sce);
	}
	if( HPMHooks.count.HP_chrif_save_scdata_single_post ) {
		void (*postHookFunc) (int account_id, int char_id, short type, struct status_change_entry *sce);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_save_scdata_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_save_scdata_single_post[hIndex].func;
			postHookFunc(account_id, char_id, type, sce);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.chrif.del_scdata_single(account_id, char_id, type);
	}
	if( HPMHooks.count.HP_chrif_del_scdata_single_post ) {
		void (*postHookFunc) (int account_id, int char_id, short type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_chrif_del_scdata_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_chrif_del_scdata_single_post[hIndex].func;
			postHookFunc(account_id, char_id, type);
		}
	}
	return;
}
/* clif_interface */
int HP_clif_init(bool minimal) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.init(minimal);
	}
	if( HPMHooks.count.HP_clif_init_post ) {
		int (*postHookFunc) (int retVal___, bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, minimal);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.final();
	}
	if( HPMHooks.count.HP_clif_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_clif_setip(const char *ip) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.setip(ip);
	}
	if( HPMHooks.count.HP_clif_setip_post ) {
		bool (*postHookFunc) (bool retVal___, const char *ip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_setip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip);
		}
	}
	return retVal___;
}
bool HP_clif_setbindip(const char *ip) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.setbindip(ip);
	}
	if( HPMHooks.count.HP_clif_setbindip_post ) {
		bool (*postHookFunc) (bool retVal___, const char *ip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setbindip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_setbindip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.setport(port);
	}
	if( HPMHooks.count.HP_clif_setport_post ) {
		void (*postHookFunc) (uint16 port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_setport_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_setport_post[hIndex].func;
			postHookFunc(port);
		}
	}
	return;
}
uint32 HP_clif_refresh_ip(void) {
	int hIndex = 0;
	uint32 retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.refresh_ip();
	}
	if( HPMHooks.count.HP_clif_refresh_ip_post ) {
		uint32 (*postHookFunc) (uint32 retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_ip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_refresh_ip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_clif_send(const void *buf, int len, struct block_list *bl, enum send_target type) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.send(buf, len, bl, type);
	}
	if( HPMHooks.count.HP_clif_send_post ) {
		bool (*postHookFunc) (bool retVal___, const void *buf, int len, struct block_list *bl, enum send_target type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_send_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, buf, len, bl, type);
		}
	}
	return retVal___;
}
int HP_clif_send_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.clif.send_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_clif_send_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_clif_send_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_clif_send_actual(int fd, void *buf, int len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_clif_send_actual_pre ) {
		int (*preHookFunc) (int *fd, void **buf, int *len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_actual_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_send_actual_pre[hIndex].func;
			retVal___ = preHookFunc(&fd, &buf, &len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.send_actual(fd, buf, len);
	}
	if( HPMHooks.count.HP_clif_send_actual_post ) {
		int (*postHookFunc) (int retVal___, int fd, void *buf, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_actual_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_send_actual_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd, buf, len);
		}
	}
	return retVal___;
}
int HP_clif_parse(int fd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.parse(fd);
	}
	if( HPMHooks.count.HP_clif_parse_post ) {
		int (*postHookFunc) (int retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_parse_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
const struct s_packet_db* HP_clif_packet(int packet_id) {
	int hIndex = 0;
	const struct s_packet_db* retVal___ = NULL;
	if( HPMHooks.count.HP_clif_packet_pre ) {
		const struct s_packet_db* (*preHookFunc) (int *packet_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_packet_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_packet_pre[hIndex].func;
			retVal___ = preHookFunc(&packet_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.packet(packet_id);
	}
	if( HPMHooks.count.HP_clif_packet_post ) {
		const struct s_packet_db* (*postHookFunc) (const struct s_packet_db* retVal___, int packet_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_packet_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_packet_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, packet_id);
		}
	}
	return retVal___;
}
unsigned short HP_clif_parse_cmd(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.parse_cmd(fd, sd);
	}
	if( HPMHooks.count.HP_clif_parse_cmd_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_cmd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_parse_cmd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd, sd);
		}
	}
	return retVal___;
}
unsigned short HP_clif_decrypt_cmd(int cmd, struct map_session_data *sd) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.decrypt_cmd(cmd, sd);
	}
	if( HPMHooks.count.HP_clif_decrypt_cmd_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, int cmd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_decrypt_cmd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_decrypt_cmd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cmd, sd);
		}
	}
	return retVal___;
}
void HP_clif_authok(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_authok_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.authok(sd);
	}
	if( HPMHooks.count.HP_clif_authok_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_authok_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_authrefuse(int fd, uint8 error_code) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_authrefuse_pre ) {
		void (*preHookFunc) (int *fd, uint8 *error_code);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.authrefuse(fd, error_code);
	}
	if( HPMHooks.count.HP_clif_authrefuse_post ) {
		void (*postHookFunc) (int fd, uint8 error_code);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authrefuse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_authrefuse_post[hIndex].func;
			postHookFunc(fd, error_code);
		}
	}
	return;
}
void HP_clif_authfail_fd(int fd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_authfail_fd_pre ) {
		void (*preHookFunc) (int *fd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.authfail_fd(fd, type);
	}
	if( HPMHooks.count.HP_clif_authfail_fd_post ) {
		void (*postHookFunc) (int fd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_authfail_fd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_authfail_fd_post[hIndex].func;
			postHookFunc(fd, type);
		}
	}
	return;
}
void HP_clif_charselectok(int id, uint8 ok) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_charselectok_pre ) {
		void (*preHookFunc) (int *id, uint8 *ok);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.charselectok(id, ok);
	}
	if( HPMHooks.count.HP_clif_charselectok_post ) {
		void (*postHookFunc) (int id, uint8 ok);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charselectok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_charselectok_post[hIndex].func;
			postHookFunc(id, ok);
		}
	}
	return;
}
void HP_clif_dropflooritem(struct flooritem_data *fitem) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_dropflooritem_pre ) {
		void (*preHookFunc) (struct flooritem_data **fitem);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.dropflooritem(fitem);
	}
	if( HPMHooks.count.HP_clif_dropflooritem_post ) {
		void (*postHookFunc) (struct flooritem_data *fitem);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropflooritem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_dropflooritem_post[hIndex].func;
			postHookFunc(fitem);
		}
	}
	return;
}
void HP_clif_clearflooritem(struct flooritem_data *fitem, int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_clearflooritem_pre ) {
		void (*preHookFunc) (struct flooritem_data **fitem, int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.clearflooritem(fitem, fd);
	}
	if( HPMHooks.count.HP_clif_clearflooritem_post ) {
		void (*postHookFunc) (struct flooritem_data *fitem, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearflooritem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_clearflooritem_post[hIndex].func;
			postHookFunc(fitem, fd);
		}
	}
	return;
}
void HP_clif_additem(struct map_session_data *sd, int n, int amount, int fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_additem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount, int *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.additem(sd, n, amount, fail);
	}
	if( HPMHooks.count.HP_clif_additem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int n, int amount, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_additem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_additem_post[hIndex].func;
			postHookFunc(sd, n, amount, fail);
		}
	}
	return;
}
void HP_clif_dropitem(struct map_session_data *sd, int n, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_dropitem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.dropitem(sd, n, amount);
	}
	if( HPMHooks.count.HP_clif_dropitem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int n, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dropitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_dropitem_post[hIndex].func;
			postHookFunc(sd, n, amount);
		}
	}
	return;
}
void HP_clif_delitem(struct map_session_data *sd, int n, int amount, short reason) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_delitem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount, short *reason);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.delitem(sd, n, amount, reason);
	}
	if( HPMHooks.count.HP_clif_delitem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int n, int amount, short reason);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_delitem_post[hIndex].func;
			postHookFunc(sd, n, amount, reason);
		}
	}
	return;
}
void HP_clif_takeitem(struct block_list *src, struct block_list *dst) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_takeitem_pre ) {
		void (*preHookFunc) (struct block_list **src, struct block_list **dst);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.takeitem(src, dst);
	}
	if( HPMHooks.count.HP_clif_takeitem_post ) {
		void (*postHookFunc) (struct block_list *src, struct block_list *dst);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_takeitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_takeitem_post[hIndex].func;
			postHookFunc(src, dst);
		}
	}
	return;
}
void HP_clif_item_equip(short idx, struct EQUIPITEM_INFO *p, struct item *i, struct item_data *id, int eqp_pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_equip_pre ) {
		void (*preHookFunc) (short *idx, struct EQUIPITEM_INFO **p, struct item **i, struct item_data **id, int *eqp_pos);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_equip_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_item_equip_pre[hIndex].func;
			preHookFunc(&idx, &p, &i, &id, &eqp_pos);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_equip(idx, p, i, id, eqp_pos);
	}
	if( HPMHooks.count.HP_clif_item_equip_post ) {
		void (*postHookFunc) (short idx, struct EQUIPITEM_INFO *p, struct item *i, struct item_data *id, int eqp_pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_equip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_equip_post[hIndex].func;
			postHookFunc(idx, p, i, id, eqp_pos);
		}
	}
	return;
}
void HP_clif_item_normal(short idx, struct NORMALITEM_INFO *p, struct item *i, struct item_data *id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_normal_pre ) {
		void (*preHookFunc) (short *idx, struct NORMALITEM_INFO **p, struct item **i, struct item_data **id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_normal_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_item_normal_pre[hIndex].func;
			preHookFunc(&idx, &p, &i, &id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_normal(idx, p, i, id);
	}
	if( HPMHooks.count.HP_clif_item_normal_post ) {
		void (*postHookFunc) (short idx, struct NORMALITEM_INFO *p, struct item *i, struct item_data *id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_normal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_normal_post[hIndex].func;
			postHookFunc(idx, p, i, id);
		}
	}
	return;
}
void HP_clif_arrowequip(struct map_session_data *sd, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_arrowequip_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.arrowequip(sd, val);
	}
	if( HPMHooks.count.HP_clif_arrowequip_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrowequip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_arrowequip_post[hIndex].func;
			postHookFunc(sd, val);
		}
	}
	return;
}
void HP_clif_arrow_fail(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_arrow_fail_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.arrow_fail(sd, type);
	}
	if( HPMHooks.count.HP_clif_arrow_fail_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_fail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_arrow_fail_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_use_card(struct map_session_data *sd, int idx) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_use_card_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *idx);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.use_card(sd, idx);
	}
	if( HPMHooks.count.HP_clif_use_card_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_use_card_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_use_card_post[hIndex].func;
			postHookFunc(sd, idx);
		}
	}
	return;
}
void HP_clif_cart_additem(struct map_session_data *sd, int n, int amount, int fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cart_additem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount, int *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cart_additem(sd, n, amount, fail);
	}
	if( HPMHooks.count.HP_clif_cart_additem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int n, int amount, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cart_additem_post[hIndex].func;
			postHookFunc(sd, n, amount, fail);
		}
	}
	return;
}
void HP_clif_cart_delitem(struct map_session_data *sd, int n, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cart_delitem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *n, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cart_delitem(sd, n, amount);
	}
	if( HPMHooks.count.HP_clif_cart_delitem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int n, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_delitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cart_delitem_post[hIndex].func;
			postHookFunc(sd, n, amount);
		}
	}
	return;
}
void HP_clif_equipitemack(struct map_session_data *sd, int n, int pos, enum e_EQUIP_ITEM_ACK result) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.equipitemack(sd, n, pos, result);
	}
	if( HPMHooks.count.HP_clif_equipitemack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int n, int pos, enum e_EQUIP_ITEM_ACK result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equipitemack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_equipitemack_post[hIndex].func;
			postHookFunc(sd, n, pos, result);
		}
	}
	return;
}
void HP_clif_unequipitemack(struct map_session_data *sd, int n, int pos, enum e_UNEQUIP_ITEM_ACK result) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.unequipitemack(sd, n, pos, result);
	}
	if( HPMHooks.count.HP_clif_unequipitemack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int n, int pos, enum e_UNEQUIP_ITEM_ACK result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_unequipitemack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_unequipitemack_post[hIndex].func;
			postHookFunc(sd, n, pos, result);
		}
	}
	return;
}
void HP_clif_useitemack(struct map_session_data *sd, int index, int amount, bool ok) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_useitemack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *index, int *amount, bool *ok);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.useitemack(sd, index, amount, ok);
	}
	if( HPMHooks.count.HP_clif_useitemack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int index, int amount, bool ok);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_useitemack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_useitemack_post[hIndex].func;
			postHookFunc(sd, index, amount, ok);
		}
	}
	return;
}
void HP_clif_addcards(unsigned char *buf, struct item *item) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_addcards_pre ) {
		void (*preHookFunc) (unsigned char **buf, struct item **item);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.addcards(buf, item);
	}
	if( HPMHooks.count.HP_clif_addcards_post ) {
		void (*postHookFunc) (unsigned char *buf, struct item *item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_addcards_post[hIndex].func;
			postHookFunc(buf, item);
		}
	}
	return;
}
void HP_clif_addcards2(unsigned short *cards, struct item *item) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_addcards2_pre ) {
		void (*preHookFunc) (unsigned short **cards, struct item **item);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.addcards2(cards, item);
	}
	if( HPMHooks.count.HP_clif_addcards2_post ) {
		void (*postHookFunc) (unsigned short *cards, struct item *item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addcards2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_addcards2_post[hIndex].func;
			postHookFunc(cards, item);
		}
	}
	return;
}
void HP_clif_item_sub(unsigned char *buf, int n, struct item *i, struct item_data *id, int equip) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_sub_pre ) {
		void (*preHookFunc) (unsigned char **buf, int *n, struct item **i, struct item_data **id, int *equip);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_sub(buf, n, i, id, equip);
	}
	if( HPMHooks.count.HP_clif_item_sub_post ) {
		void (*postHookFunc) (unsigned char *buf, int n, struct item *i, struct item_data *id, int equip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_sub_post[hIndex].func;
			postHookFunc(buf, n, i, id, equip);
		}
	}
	return;
}
void HP_clif_getareachar_item(struct map_session_data *sd, struct flooritem_data *fitem) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_getareachar_item_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct flooritem_data **fitem);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.getareachar_item(sd, fitem);
	}
	if( HPMHooks.count.HP_clif_getareachar_item_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct flooritem_data *fitem);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_getareachar_item_post[hIndex].func;
			postHookFunc(sd, fitem);
		}
	}
	return;
}
void HP_clif_cart_additem_ack(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cart_additem_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cart_additem_ack(sd, flag);
	}
	if( HPMHooks.count.HP_clif_cart_additem_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cart_additem_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cart_additem_ack_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_cashshop_load(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cashshop_load_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cashshop_load();
	}
	if( HPMHooks.count.HP_clif_cashshop_load_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_load_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cashshop_load_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_clif_package_announce(struct map_session_data *sd, unsigned short nameid, unsigned short containerid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_package_announce_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short *nameid, unsigned short *containerid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.package_announce(sd, nameid, containerid);
	}
	if( HPMHooks.count.HP_clif_package_announce_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short nameid, unsigned short containerid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_package_announce_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_package_announce_post[hIndex].func;
			postHookFunc(sd, nameid, containerid);
		}
	}
	return;
}
void HP_clif_item_drop_announce(struct map_session_data *sd, unsigned short nameid, char *monsterName) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_drop_announce(sd, nameid, monsterName);
	}
	if( HPMHooks.count.HP_clif_item_drop_announce_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short nameid, char *monsterName);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_drop_announce_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_drop_announce_post[hIndex].func;
			postHookFunc(sd, nameid, monsterName);
		}
	}
	return;
}
void HP_clif_clearunit_single(int id, clr_type type, int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_clearunit_single_pre ) {
		void (*preHookFunc) (int *id, clr_type *type, int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.clearunit_single(id, type, fd);
	}
	if( HPMHooks.count.HP_clif_clearunit_single_post ) {
		void (*postHookFunc) (int id, clr_type type, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_clearunit_single_post[hIndex].func;
			postHookFunc(id, type, fd);
		}
	}
	return;
}
void HP_clif_clearunit_area(struct block_list *bl, clr_type type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_clearunit_area_pre ) {
		void (*preHookFunc) (struct block_list **bl, clr_type *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.clearunit_area(bl, type);
	}
	if( HPMHooks.count.HP_clif_clearunit_area_post ) {
		void (*postHookFunc) (struct block_list *bl, clr_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_area_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_clearunit_area_post[hIndex].func;
			postHookFunc(bl, type);
		}
	}
	return;
}
void HP_clif_clearunit_delayed(struct block_list *bl, clr_type type, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.clearunit_delayed(bl, type, tick);
	}
	if( HPMHooks.count.HP_clif_clearunit_delayed_post ) {
		void (*postHookFunc) (struct block_list *bl, clr_type type, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_post[hIndex].func;
			postHookFunc(bl, type, tick);
		}
	}
	return;
}
void HP_clif_walkok(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_walkok_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.walkok(sd);
	}
	if( HPMHooks.count.HP_clif_walkok_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_walkok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_walkok_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_move(struct unit_data *ud) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_move_pre ) {
		void (*preHookFunc) (struct unit_data **ud);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.move(ud);
	}
	if( HPMHooks.count.HP_clif_move_post ) {
		void (*postHookFunc) (struct unit_data *ud);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_move_post[hIndex].func;
			postHookFunc(ud);
		}
	}
	return;
}
void HP_clif_move2(struct block_list *bl, struct view_data *vd, struct unit_data *ud) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_move2_pre ) {
		void (*preHookFunc) (struct block_list **bl, struct view_data **vd, struct unit_data **ud);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.move2(bl, vd, ud);
	}
	if( HPMHooks.count.HP_clif_move2_post ) {
		void (*postHookFunc) (struct block_list *bl, struct view_data *vd, struct unit_data *ud);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_move2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_move2_post[hIndex].func;
			postHookFunc(bl, vd, ud);
		}
	}
	return;
}
void HP_clif_blown(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_blown_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.blown(bl);
	}
	if( HPMHooks.count.HP_clif_blown_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_blown_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_slide(struct block_list *bl, int x, int y) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_slide_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *x, int *y);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.slide(bl, x, y);
	}
	if( HPMHooks.count.HP_clif_slide_post ) {
		void (*postHookFunc) (struct block_list *bl, int x, int y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_slide_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_slide_post[hIndex].func;
			postHookFunc(bl, x, y);
		}
	}
	return;
}
void HP_clif_fixpos(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_fixpos_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.fixpos(bl);
	}
	if( HPMHooks.count.HP_clif_fixpos_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fixpos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_fixpos_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_changelook(struct block_list *bl, int type, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changelook_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *type, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changelook(bl, type, val);
	}
	if( HPMHooks.count.HP_clif_changelook_post ) {
		void (*postHookFunc) (struct block_list *bl, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changelook_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changelook_post[hIndex].func;
			postHookFunc(bl, type, val);
		}
	}
	return;
}
void HP_clif_changetraplook(struct block_list *bl, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changetraplook_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changetraplook(bl, val);
	}
	if( HPMHooks.count.HP_clif_changetraplook_post ) {
		void (*postHookFunc) (struct block_list *bl, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changetraplook_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changetraplook_post[hIndex].func;
			postHookFunc(bl, val);
		}
	}
	return;
}
void HP_clif_refreshlook(struct block_list *bl, int id, int type, int val, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_refreshlook_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *id, int *type, int *val, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.refreshlook(bl, id, type, val, target);
	}
	if( HPMHooks.count.HP_clif_refreshlook_post ) {
		void (*postHookFunc) (struct block_list *bl, int id, int type, int val, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refreshlook_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_refreshlook_post[hIndex].func;
			postHookFunc(bl, id, type, val, target);
		}
	}
	return;
}
void HP_clif_sendlook(struct block_list *bl, int id, int type, int val, int val2, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sendlook_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *id, int *type, int *val, int *val2, enum send_target *target);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendlook_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_sendlook_pre[hIndex].func;
			preHookFunc(&bl, &id, &type, &val, &val2, &target);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sendlook(bl, id, type, val, val2, target);
	}
	if( HPMHooks.count.HP_clif_sendlook_post ) {
		void (*postHookFunc) (struct block_list *bl, int id, int type, int val, int val2, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendlook_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sendlook_post[hIndex].func;
			postHookFunc(bl, id, type, val, val2, target);
		}
	}
	return;
}
void HP_clif_class_change(struct block_list *bl, int class_, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_class_change_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *class_, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.class_change(bl, class_, type);
	}
	if( HPMHooks.count.HP_clif_class_change_post ) {
		void (*postHookFunc) (struct block_list *bl, int class_, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_class_change_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_class_change_post[hIndex].func;
			postHookFunc(bl, class_, type);
		}
	}
	return;
}
void HP_clif_skill_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_delunit(su);
	}
	if( HPMHooks.count.HP_clif_skill_delunit_post ) {
		void (*postHookFunc) (struct skill_unit *su);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_delunit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_delunit_post[hIndex].func;
			postHookFunc(su);
		}
	}
	return;
}
void HP_clif_skillunit_update(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skillunit_update_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skillunit_update(bl);
	}
	if( HPMHooks.count.HP_clif_skillunit_update_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillunit_update_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skillunit_update_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
int HP_clif_clearunit_delayed_sub(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.clearunit_delayed_sub(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_clif_clearunit_delayed_sub_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearunit_delayed_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_clearunit_delayed_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_clif_set_unit_idle(struct block_list *bl, struct map_session_data *tsd, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_set_unit_idle_pre ) {
		void (*preHookFunc) (struct block_list **bl, struct map_session_data **tsd, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.set_unit_idle(bl, tsd, target);
	}
	if( HPMHooks.count.HP_clif_set_unit_idle_post ) {
		void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_set_unit_idle_post[hIndex].func;
			postHookFunc(bl, tsd, target);
		}
	}
	return;
}
void HP_clif_spawn_unit(struct block_list *bl, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_spawn_unit_pre ) {
		void (*preHookFunc) (struct block_list **bl, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.spawn_unit(bl, target);
	}
	if( HPMHooks.count.HP_clif_spawn_unit_post ) {
		void (*postHookFunc) (struct block_list *bl, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_spawn_unit_post[hIndex].func;
			postHookFunc(bl, target);
		}
	}
	return;
}
void HP_clif_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.spawn_unit2(bl, target);
	}
	if( HPMHooks.count.HP_clif_spawn_unit2_post ) {
		void (*postHookFunc) (struct block_list *bl, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_unit2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_spawn_unit2_post[hIndex].func;
			postHookFunc(bl, target);
		}
	}
	return;
}
void HP_clif_set_unit_idle2(struct block_list *bl, struct map_session_data *tsd, enum send_target target) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.set_unit_idle2(bl, tsd, target);
	}
	if( HPMHooks.count.HP_clif_set_unit_idle2_post ) {
		void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_idle2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_set_unit_idle2_post[hIndex].func;
			postHookFunc(bl, tsd, target);
		}
	}
	return;
}
void HP_clif_set_unit_walking(struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_set_unit_walking_pre ) {
		void (*preHookFunc) (struct block_list **bl, struct map_session_data **tsd, struct unit_data **ud, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.set_unit_walking(bl, tsd, ud, target);
	}
	if( HPMHooks.count.HP_clif_set_unit_walking_post ) {
		void (*postHookFunc) (struct block_list *bl, struct map_session_data *tsd, struct unit_data *ud, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_set_unit_walking_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_set_unit_walking_post[hIndex].func;
			postHookFunc(bl, tsd, ud, target);
		}
	}
	return;
}
int HP_clif_calc_walkdelay(struct block_list *bl, int delay, int type, int damage, int div_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.calc_walkdelay(bl, delay, type, damage, div_);
	}
	if( HPMHooks.count.HP_clif_calc_walkdelay_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int delay, int type, int damage, int div_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_calc_walkdelay_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_calc_walkdelay_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, delay, type, damage, div_);
		}
	}
	return retVal___;
}
void HP_clif_getareachar_skillunit(struct block_list *bl, struct skill_unit *su, enum send_target target) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.getareachar_skillunit(bl, su, target);
	}
	if( HPMHooks.count.HP_clif_getareachar_skillunit_post ) {
		void (*postHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_skillunit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_getareachar_skillunit_post[hIndex].func;
			postHookFunc(bl, su, target);
		}
	}
	return;
}
void HP_clif_getareachar_unit(struct map_session_data *sd, struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_getareachar_unit_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.getareachar_unit(sd, bl);
	}
	if( HPMHooks.count.HP_clif_getareachar_unit_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_unit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_getareachar_unit_post[hIndex].func;
			postHookFunc(sd, bl);
		}
	}
	return;
}
void HP_clif_clearchar_skillunit(struct skill_unit *su, int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_clearchar_skillunit_pre ) {
		void (*preHookFunc) (struct skill_unit **su, int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.clearchar_skillunit(su, fd);
	}
	if( HPMHooks.count.HP_clif_clearchar_skillunit_post ) {
		void (*postHookFunc) (struct skill_unit *su, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchar_skillunit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_clearchar_skillunit_post[hIndex].func;
			postHookFunc(su, fd);
		}
	}
	return;
}
int HP_clif_getareachar(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.clif.getareachar(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_clif_getareachar_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_clif_getareachar_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_clif_graffiti_entry(struct block_list *bl, struct skill_unit *su, enum send_target target) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.graffiti_entry(bl, su, target);
	}
	if( HPMHooks.count.HP_clif_graffiti_entry_post ) {
		void (*postHookFunc) (struct block_list *bl, struct skill_unit *su, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_graffiti_entry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_graffiti_entry_post[hIndex].func;
			postHookFunc(bl, su, target);
		}
	}
	return;
}
bool HP_clif_spawn(struct block_list *bl) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.spawn(bl);
	}
	if( HPMHooks.count.HP_clif_spawn_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_spawn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
void HP_clif_changemap(struct map_session_data *sd, short m, int x, int y) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changemap_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *m, int *x, int *y);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changemap(sd, m, x, y);
	}
	if( HPMHooks.count.HP_clif_changemap_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short m, int x, int y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changemap_post[hIndex].func;
			postHookFunc(sd, m, x, y);
		}
	}
	return;
}
void HP_clif_changemapcell(int fd, int16 m, int x, int y, int type, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changemapcell_pre ) {
		void (*preHookFunc) (int *fd, int16 *m, int *x, int *y, int *type, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changemapcell(fd, m, x, y, type, target);
	}
	if( HPMHooks.count.HP_clif_changemapcell_post ) {
		void (*postHookFunc) (int fd, int16 m, int x, int y, int type, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapcell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changemapcell_post[hIndex].func;
			postHookFunc(fd, m, x, y, type, target);
		}
	}
	return;
}
void HP_clif_map_property(struct map_session_data *sd, enum map_property property) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_map_property_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum map_property *property);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.map_property(sd, property);
	}
	if( HPMHooks.count.HP_clif_map_property_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum map_property property);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_map_property_post[hIndex].func;
			postHookFunc(sd, property);
		}
	}
	return;
}
void HP_clif_pvpset(struct map_session_data *sd, int pvprank, int pvpnum, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pvpset_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *pvprank, int *pvpnum, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pvpset(sd, pvprank, pvpnum, type);
	}
	if( HPMHooks.count.HP_clif_pvpset_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int pvprank, int pvpnum, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pvpset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pvpset_post[hIndex].func;
			postHookFunc(sd, pvprank, pvpnum, type);
		}
	}
	return;
}
void HP_clif_map_property_mapall(int mapid, enum map_property property) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_map_property_mapall_pre ) {
		void (*preHookFunc) (int *mapid, enum map_property *property);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.map_property_mapall(mapid, property);
	}
	if( HPMHooks.count.HP_clif_map_property_mapall_post ) {
		void (*postHookFunc) (int mapid, enum map_property property);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_property_mapall_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_map_property_mapall_post[hIndex].func;
			postHookFunc(mapid, property);
		}
	}
	return;
}
void HP_clif_bossmapinfo(int fd, struct mob_data *md, short flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bossmapinfo_pre ) {
		void (*preHookFunc) (int *fd, struct mob_data **md, short *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bossmapinfo(fd, md, flag);
	}
	if( HPMHooks.count.HP_clif_bossmapinfo_post ) {
		void (*postHookFunc) (int fd, struct mob_data *md, short flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bossmapinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bossmapinfo_post[hIndex].func;
			postHookFunc(fd, md, flag);
		}
	}
	return;
}
void HP_clif_map_type(struct map_session_data *sd, enum map_type type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_map_type_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum map_type *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.map_type(sd, type);
	}
	if( HPMHooks.count.HP_clif_map_type_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum map_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_map_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_map_type_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_maptypeproperty2(struct block_list *bl, enum send_target t) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_maptypeproperty2_pre ) {
		void (*preHookFunc) (struct block_list **bl, enum send_target *t);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.maptypeproperty2(bl, t);
	}
	if( HPMHooks.count.HP_clif_maptypeproperty2_post ) {
		void (*postHookFunc) (struct block_list *bl, enum send_target t);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_maptypeproperty2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_maptypeproperty2_post[hIndex].func;
			postHookFunc(bl, t);
		}
	}
	return;
}
void HP_clif_changemapserver(struct map_session_data *sd, unsigned short map_index, int x, int y, uint32 ip, uint16 port) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changemapserver_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short *map_index, int *x, int *y, uint32 *ip, uint16 *port);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changemapserver(sd, map_index, x, y, ip, port);
	}
	if( HPMHooks.count.HP_clif_changemapserver_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short map_index, int x, int y, uint32 ip, uint16 port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changemapserver_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changemapserver_post[hIndex].func;
			postHookFunc(sd, map_index, x, y, ip, port);
		}
	}
	return;
}
void HP_clif_npcbuysell(struct map_session_data *sd, int id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_npcbuysell_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.npcbuysell(sd, id);
	}
	if( HPMHooks.count.HP_clif_npcbuysell_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npcbuysell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_npcbuysell_post[hIndex].func;
			postHookFunc(sd, id);
		}
	}
	return;
}
void HP_clif_buylist(struct map_session_data *sd, struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buylist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buylist(sd, nd);
	}
	if( HPMHooks.count.HP_clif_buylist_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buylist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buylist_post[hIndex].func;
			postHookFunc(sd, nd);
		}
	}
	return;
}
void HP_clif_selllist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_selllist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.selllist(sd);
	}
	if( HPMHooks.count.HP_clif_selllist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_selllist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_selllist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_cashshop_show(struct map_session_data *sd, struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cashshop_show_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cashshop_show(sd, nd);
	}
	if( HPMHooks.count.HP_clif_cashshop_show_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_show_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cashshop_show_post[hIndex].func;
			postHookFunc(sd, nd);
		}
	}
	return;
}
void HP_clif_npc_buy_result(struct map_session_data *sd, unsigned char result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_npc_buy_result_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *result);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.npc_buy_result(sd, result);
	}
	if( HPMHooks.count.HP_clif_npc_buy_result_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_buy_result_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_npc_buy_result_post[hIndex].func;
			postHookFunc(sd, result);
		}
	}
	return;
}
void HP_clif_npc_sell_result(struct map_session_data *sd, unsigned char result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_npc_sell_result_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *result);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.npc_sell_result(sd, result);
	}
	if( HPMHooks.count.HP_clif_npc_sell_result_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_sell_result_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_npc_sell_result_post[hIndex].func;
			postHookFunc(sd, result);
		}
	}
	return;
}
void HP_clif_cashshop_ack(struct map_session_data *sd, int error) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cashshop_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *error);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cashshop_ack(sd, error);
	}
	if( HPMHooks.count.HP_clif_cashshop_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int error);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cashshop_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cashshop_ack_post[hIndex].func;
			postHookFunc(sd, error);
		}
	}
	return;
}
void HP_clif_scriptmes(struct map_session_data *sd, int npcid, const char *mes) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_scriptmes_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npcid, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.scriptmes(sd, npcid, mes);
	}
	if( HPMHooks.count.HP_clif_scriptmes_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npcid, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmes_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_scriptmes_post[hIndex].func;
			postHookFunc(sd, npcid, mes);
		}
	}
	return;
}
void HP_clif_scriptnext(struct map_session_data *sd, int npcid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_scriptnext_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npcid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.scriptnext(sd, npcid);
	}
	if( HPMHooks.count.HP_clif_scriptnext_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npcid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptnext_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_scriptnext_post[hIndex].func;
			postHookFunc(sd, npcid);
		}
	}
	return;
}
void HP_clif_scriptclose(struct map_session_data *sd, int npcid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_scriptclose_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npcid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.scriptclose(sd, npcid);
	}
	if( HPMHooks.count.HP_clif_scriptclose_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npcid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclose_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_scriptclose_post[hIndex].func;
			postHookFunc(sd, npcid);
		}
	}
	return;
}
void HP_clif_scriptmenu(struct map_session_data *sd, int npcid, const char *mes) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_scriptmenu_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npcid, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.scriptmenu(sd, npcid, mes);
	}
	if( HPMHooks.count.HP_clif_scriptmenu_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npcid, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptmenu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_scriptmenu_post[hIndex].func;
			postHookFunc(sd, npcid, mes);
		}
	}
	return;
}
void HP_clif_scriptinput(struct map_session_data *sd, int npcid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_scriptinput_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npcid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.scriptinput(sd, npcid);
	}
	if( HPMHooks.count.HP_clif_scriptinput_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npcid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinput_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_scriptinput_post[hIndex].func;
			postHookFunc(sd, npcid);
		}
	}
	return;
}
void HP_clif_scriptinputstr(struct map_session_data *sd, int npcid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_scriptinputstr_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npcid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.scriptinputstr(sd, npcid);
	}
	if( HPMHooks.count.HP_clif_scriptinputstr_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npcid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptinputstr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_scriptinputstr_post[hIndex].func;
			postHookFunc(sd, npcid);
		}
	}
	return;
}
void HP_clif_cutin(struct map_session_data *sd, const char *image, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cutin_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **image, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cutin(sd, image, type);
	}
	if( HPMHooks.count.HP_clif_cutin_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *image, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cutin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cutin_post[hIndex].func;
			postHookFunc(sd, image, type);
		}
	}
	return;
}
void HP_clif_sendfakenpc(struct map_session_data *sd, int npcid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sendfakenpc_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npcid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sendfakenpc(sd, npcid);
	}
	if( HPMHooks.count.HP_clif_sendfakenpc_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npcid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendfakenpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sendfakenpc_post[hIndex].func;
			postHookFunc(sd, npcid);
		}
	}
	return;
}
void HP_clif_scriptclear(struct map_session_data *sd, int npcid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_scriptclear_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npcid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.scriptclear(sd, npcid);
	}
	if( HPMHooks.count.HP_clif_scriptclear_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npcid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_scriptclear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_scriptclear_post[hIndex].func;
			postHookFunc(sd, npcid);
		}
	}
	return;
}
void HP_clif_viewpoint(struct map_session_data *sd, int npc_id, int type, int x, int y, int id, int color) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_viewpoint_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *npc_id, int *type, int *x, int *y, int *id, int *color);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.viewpoint(sd, npc_id, type, x, y, id, color);
	}
	if( HPMHooks.count.HP_clif_viewpoint_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int npc_id, int type, int x, int y, int id, int color);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewpoint_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_viewpoint_post[hIndex].func;
			postHookFunc(sd, npc_id, type, x, y, id, color);
		}
	}
	return;
}
int HP_clif_damage(struct block_list *src, struct block_list *dst, int sdelay, int ddelay, int64 damage, short div, unsigned char type, int64 damage2) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.damage(src, dst, sdelay, ddelay, damage, div, type, damage2);
	}
	if( HPMHooks.count.HP_clif_damage_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, int sdelay, int ddelay, int64 damage, short div, unsigned char type, int64 damage2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, dst, sdelay, ddelay, damage, div, type, damage2);
		}
	}
	return retVal___;
}
void HP_clif_sitting(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sitting_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sitting(bl);
	}
	if( HPMHooks.count.HP_clif_sitting_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sitting_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sitting_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_standing(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_standing_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.standing(bl);
	}
	if( HPMHooks.count.HP_clif_standing_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_standing_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_standing_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_arrow_create_list(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_arrow_create_list_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.arrow_create_list(sd);
	}
	if( HPMHooks.count.HP_clif_arrow_create_list_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_arrow_create_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_arrow_create_list_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_refresh_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.refresh_storagewindow(sd);
	}
	if( HPMHooks.count.HP_clif_refresh_storagewindow_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_storagewindow_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_refresh_storagewindow_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_refresh(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_refresh_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.refresh(sd);
	}
	if( HPMHooks.count.HP_clif_refresh_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refresh_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_refresh_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_fame_blacksmith(struct map_session_data *sd, int points) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_fame_blacksmith_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *points);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.fame_blacksmith(sd, points);
	}
	if( HPMHooks.count.HP_clif_fame_blacksmith_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int points);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_blacksmith_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_fame_blacksmith_post[hIndex].func;
			postHookFunc(sd, points);
		}
	}
	return;
}
void HP_clif_fame_alchemist(struct map_session_data *sd, int points) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_fame_alchemist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *points);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.fame_alchemist(sd, points);
	}
	if( HPMHooks.count.HP_clif_fame_alchemist_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int points);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_alchemist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_fame_alchemist_post[hIndex].func;
			postHookFunc(sd, points);
		}
	}
	return;
}
void HP_clif_fame_taekwon(struct map_session_data *sd, int points) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_fame_taekwon_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *points);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.fame_taekwon(sd, points);
	}
	if( HPMHooks.count.HP_clif_fame_taekwon_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int points);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_fame_taekwon_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_fame_taekwon_post[hIndex].func;
			postHookFunc(sd, points);
		}
	}
	return;
}
void HP_clif_ranklist(struct map_session_data *sd, enum fame_list_type type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_ranklist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum fame_list_type *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.ranklist(sd, type);
	}
	if( HPMHooks.count.HP_clif_ranklist_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum fame_list_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranklist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_ranklist_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_update_rankingpoint(struct map_session_data *sd, enum fame_list_type type, int points) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_update_rankingpoint_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum fame_list_type *type, int *points);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.update_rankingpoint(sd, type, points);
	}
	if( HPMHooks.count.HP_clif_update_rankingpoint_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum fame_list_type type, int points);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_update_rankingpoint_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_update_rankingpoint_post[hIndex].func;
			postHookFunc(sd, type, points);
		}
	}
	return;
}
void HP_clif_pRanklist(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRanklist_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRanklist(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRanklist_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRanklist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRanklist_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_hotkeys(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_hotkeys_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.hotkeys(sd);
	}
	if( HPMHooks.count.HP_clif_hotkeys_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hotkeys_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_hotkeys_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_clif_insight(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.clif.insight(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_clif_insight_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insight_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_clif_insight_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_clif_outsight(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.clif.outsight(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_clif_outsight_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_outsight_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_clif_outsight_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_clif_skillcastcancel(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skillcastcancel_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skillcastcancel(bl);
	}
	if( HPMHooks.count.HP_clif_skillcastcancel_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillcastcancel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skillcastcancel_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_skill_fail(struct map_session_data *sd, uint16 skill_id, enum useskill_fail_cause cause, int btype) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skill_fail_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, enum useskill_fail_cause *cause, int *btype);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_fail(sd, skill_id, cause, btype);
	}
	if( HPMHooks.count.HP_clif_skill_fail_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, enum useskill_fail_cause cause, int btype);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_fail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_fail_post[hIndex].func;
			postHookFunc(sd, skill_id, cause, btype);
		}
	}
	return;
}
void HP_clif_skill_cooldown(struct map_session_data *sd, uint16 skill_id, unsigned int duration) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_cooldown(sd, skill_id, duration);
	}
	if( HPMHooks.count.HP_clif_skill_cooldown_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, unsigned int duration);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_cooldown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_cooldown_post[hIndex].func;
			postHookFunc(sd, skill_id, duration);
		}
	}
	return;
}
void HP_clif_skill_memomessage(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skill_memomessage_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_memomessage(sd, type);
	}
	if( HPMHooks.count.HP_clif_skill_memomessage_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_memomessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_memomessage_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_skill_mapinfomessage(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skill_mapinfomessage_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_mapinfomessage(sd, type);
	}
	if( HPMHooks.count.HP_clif_skill_mapinfomessage_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_mapinfomessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_mapinfomessage_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_skill_produce_mix_list(struct map_session_data *sd, int skill_id, int trigger) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skill_produce_mix_list_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *skill_id, int *trigger);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_produce_mix_list(sd, skill_id, trigger);
	}
	if( HPMHooks.count.HP_clif_skill_produce_mix_list_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int skill_id, int trigger);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_produce_mix_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_produce_mix_list_post[hIndex].func;
			postHookFunc(sd, skill_id, trigger);
		}
	}
	return;
}
void HP_clif_cooking_list(struct map_session_data *sd, int trigger, uint16 skill_id, int qty, int list_type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cooking_list_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *trigger, uint16 *skill_id, int *qty, int *list_type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cooking_list(sd, trigger, skill_id, qty, list_type);
	}
	if( HPMHooks.count.HP_clif_cooking_list_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int trigger, uint16 skill_id, int qty, int list_type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooking_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cooking_list_post[hIndex].func;
			postHookFunc(sd, trigger, skill_id, qty, list_type);
		}
	}
	return;
}
void HP_clif_autospell(struct map_session_data *sd, uint16 skill_lv) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_autospell_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_lv);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.autospell(sd, skill_lv);
	}
	if( HPMHooks.count.HP_clif_autospell_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autospell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_autospell_post[hIndex].func;
			postHookFunc(sd, skill_lv);
		}
	}
	return;
}
void HP_clif_combo_delay(struct block_list *bl, int wait) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_combo_delay_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *wait);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.combo_delay(bl, wait);
	}
	if( HPMHooks.count.HP_clif_combo_delay_post ) {
		void (*postHookFunc) (struct block_list *bl, int wait);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_combo_delay_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_combo_delay_post[hIndex].func;
			postHookFunc(bl, wait);
		}
	}
	return;
}
void HP_clif_status_change(struct block_list *bl, int type, int flag, int tick, int val1, int val2, int val3) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_status_change_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *type, int *flag, int *tick, int *val1, int *val2, int *val3);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.status_change(bl, type, flag, tick, val1, val2, val3);
	}
	if( HPMHooks.count.HP_clif_status_change_post ) {
		void (*postHookFunc) (struct block_list *bl, int type, int flag, int tick, int val1, int val2, int val3);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_status_change_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_status_change_post[hIndex].func;
			postHookFunc(bl, type, flag, tick, val1, val2, val3);
		}
	}
	return;
}
void HP_clif_insert_card(struct map_session_data *sd, int idx_equip, int idx_card, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_insert_card_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *idx_equip, int *idx_card, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.insert_card(sd, idx_equip, idx_card, flag);
	}
	if( HPMHooks.count.HP_clif_insert_card_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int idx_equip, int idx_card, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_insert_card_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_insert_card_post[hIndex].func;
			postHookFunc(sd, idx_equip, idx_card, flag);
		}
	}
	return;
}
void HP_clif_inventorylist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_inventorylist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.inventorylist(sd);
	}
	if( HPMHooks.count.HP_clif_inventorylist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_inventorylist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_inventorylist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_equiplist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_equiplist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.equiplist(sd);
	}
	if( HPMHooks.count.HP_clif_equiplist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiplist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_equiplist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_cartlist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cartlist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cartlist(sd);
	}
	if( HPMHooks.count.HP_clif_cartlist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cartlist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cartlist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_favorite_item(struct map_session_data *sd, unsigned short index) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_favorite_item_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short *index);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.favorite_item(sd, index);
	}
	if( HPMHooks.count.HP_clif_favorite_item_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_favorite_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_favorite_item_post[hIndex].func;
			postHookFunc(sd, index);
		}
	}
	return;
}
void HP_clif_clearcart(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_clearcart_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.clearcart(fd);
	}
	if( HPMHooks.count.HP_clif_clearcart_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearcart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_clearcart_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_clif_item_identify_list(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_identify_list_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_identify_list(sd);
	}
	if( HPMHooks.count.HP_clif_item_identify_list_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identify_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_identify_list_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_item_identified(struct map_session_data *sd, int idx, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_identified_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *idx, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_identified(sd, idx, flag);
	}
	if( HPMHooks.count.HP_clif_item_identified_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int idx, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_identified_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_identified_post[hIndex].func;
			postHookFunc(sd, idx, flag);
		}
	}
	return;
}
void HP_clif_item_repair_list(struct map_session_data *sd, struct map_session_data *dstsd, int lv) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_repair_list_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **dstsd, int *lv);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_repair_list(sd, dstsd, lv);
	}
	if( HPMHooks.count.HP_clif_item_repair_list_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd, int lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repair_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_repair_list_post[hIndex].func;
			postHookFunc(sd, dstsd, lv);
		}
	}
	return;
}
void HP_clif_item_repaireffect(struct map_session_data *sd, int idx, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_repaireffect_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *idx, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_repaireffect(sd, idx, flag);
	}
	if( HPMHooks.count.HP_clif_item_repaireffect_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int idx, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_repaireffect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_repaireffect_post[hIndex].func;
			postHookFunc(sd, idx, flag);
		}
	}
	return;
}
void HP_clif_item_damaged(struct map_session_data *sd, unsigned short position) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_damaged_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short *position);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_damaged(sd, position);
	}
	if( HPMHooks.count.HP_clif_item_damaged_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short position);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_damaged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_damaged_post[hIndex].func;
			postHookFunc(sd, position);
		}
	}
	return;
}
void HP_clif_item_refine_list(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_refine_list_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_refine_list(sd);
	}
	if( HPMHooks.count.HP_clif_item_refine_list_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_refine_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_refine_list_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_item_skill(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_item_skill_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.item_skill(sd, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_clif_item_skill_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_item_skill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_item_skill_post[hIndex].func;
			postHookFunc(sd, skill_id, skill_lv);
		}
	}
	return;
}
void HP_clif_mvp_item(struct map_session_data *sd, int nameid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mvp_item_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mvp_item(sd, nameid);
	}
	if( HPMHooks.count.HP_clif_mvp_item_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mvp_item_post[hIndex].func;
			postHookFunc(sd, nameid);
		}
	}
	return;
}
void HP_clif_mvp_exp(struct map_session_data *sd, unsigned int exp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mvp_exp_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *exp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mvp_exp(sd, exp);
	}
	if( HPMHooks.count.HP_clif_mvp_exp_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int exp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_exp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mvp_exp_post[hIndex].func;
			postHookFunc(sd, exp);
		}
	}
	return;
}
void HP_clif_mvp_noitem(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mvp_noitem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mvp_noitem(sd);
	}
	if( HPMHooks.count.HP_clif_mvp_noitem_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_noitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mvp_noitem_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_changed_dir(struct block_list *bl, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changed_dir_pre ) {
		void (*preHookFunc) (struct block_list **bl, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changed_dir(bl, target);
	}
	if( HPMHooks.count.HP_clif_changed_dir_post ) {
		void (*postHookFunc) (struct block_list *bl, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changed_dir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changed_dir_post[hIndex].func;
			postHookFunc(bl, target);
		}
	}
	return;
}
void HP_clif_charnameack(int fd, struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_charnameack_pre ) {
		void (*preHookFunc) (int *fd, struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.charnameack(fd, bl);
	}
	if( HPMHooks.count.HP_clif_charnameack_post ) {
		void (*postHookFunc) (int fd, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_charnameack_post[hIndex].func;
			postHookFunc(fd, bl);
		}
	}
	return;
}
void HP_clif_monster_hp_bar(struct mob_data *md, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_monster_hp_bar_pre ) {
		void (*preHookFunc) (struct mob_data **md, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.monster_hp_bar(md, sd);
	}
	if( HPMHooks.count.HP_clif_monster_hp_bar_post ) {
		void (*postHookFunc) (struct mob_data *md, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_monster_hp_bar_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_monster_hp_bar_post[hIndex].func;
			postHookFunc(md, sd);
		}
	}
	return;
}
int HP_clif_hpmeter(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.hpmeter(sd);
	}
	if( HPMHooks.count.HP_clif_hpmeter_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_hpmeter_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_clif_hpmeter_single(int fd, int id, unsigned int hp, unsigned int maxhp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_hpmeter_single_pre ) {
		void (*preHookFunc) (int *fd, int *id, unsigned int *hp, unsigned int *maxhp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.hpmeter_single(fd, id, hp, maxhp);
	}
	if( HPMHooks.count.HP_clif_hpmeter_single_post ) {
		void (*postHookFunc) (int fd, int id, unsigned int hp, unsigned int maxhp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_hpmeter_single_post[hIndex].func;
			postHookFunc(fd, id, hp, maxhp);
		}
	}
	return;
}
int HP_clif_hpmeter_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.clif.hpmeter_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_clif_hpmeter_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hpmeter_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_clif_hpmeter_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_clif_upgrademessage(int fd, int result, int item_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_upgrademessage_pre ) {
		void (*preHookFunc) (int *fd, int *result, int *item_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.upgrademessage(fd, result, item_id);
	}
	if( HPMHooks.count.HP_clif_upgrademessage_post ) {
		void (*postHookFunc) (int fd, int result, int item_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_upgrademessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_upgrademessage_post[hIndex].func;
			postHookFunc(fd, result, item_id);
		}
	}
	return;
}
void HP_clif_get_weapon_view(struct map_session_data *sd, unsigned short *rhand, unsigned short *lhand) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_get_weapon_view_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short **rhand, unsigned short **lhand);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.get_weapon_view(sd, rhand, lhand);
	}
	if( HPMHooks.count.HP_clif_get_weapon_view_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short *rhand, unsigned short *lhand);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_get_weapon_view_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_get_weapon_view_post[hIndex].func;
			postHookFunc(sd, rhand, lhand);
		}
	}
	return;
}
void HP_clif_gospel_info(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_gospel_info_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.gospel_info(sd, type);
	}
	if( HPMHooks.count.HP_clif_gospel_info_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_gospel_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_gospel_info_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_feel_req(int fd, struct map_session_data *sd, uint16 skill_lv) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_feel_req_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd, uint16 *skill_lv);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.feel_req(fd, sd, skill_lv);
	}
	if( HPMHooks.count.HP_clif_feel_req_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_req_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_feel_req_post[hIndex].func;
			postHookFunc(fd, sd, skill_lv);
		}
	}
	return;
}
void HP_clif_starskill(struct map_session_data *sd, const char *mapname, int monster_id, unsigned char star, unsigned char result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_starskill_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **mapname, int *monster_id, unsigned char *star, unsigned char *result);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.starskill(sd, mapname, monster_id, star, result);
	}
	if( HPMHooks.count.HP_clif_starskill_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *mapname, int monster_id, unsigned char star, unsigned char result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_starskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_starskill_post[hIndex].func;
			postHookFunc(sd, mapname, monster_id, star, result);
		}
	}
	return;
}
void HP_clif_feel_info(struct map_session_data *sd, unsigned char feel_level, unsigned char type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_feel_info_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *feel_level, unsigned char *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.feel_info(sd, feel_level, type);
	}
	if( HPMHooks.count.HP_clif_feel_info_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char feel_level, unsigned char type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_feel_info_post[hIndex].func;
			postHookFunc(sd, feel_level, type);
		}
	}
	return;
}
void HP_clif_hate_info(struct map_session_data *sd, unsigned char hate_level, int class_, unsigned char type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_hate_info_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *hate_level, int *class_, unsigned char *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.hate_info(sd, hate_level, class_, type);
	}
	if( HPMHooks.count.HP_clif_hate_info_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char hate_level, int class_, unsigned char type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hate_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_hate_info_post[hIndex].func;
			postHookFunc(sd, hate_level, class_, type);
		}
	}
	return;
}
void HP_clif_mission_info(struct map_session_data *sd, int mob_id, unsigned char progress) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mission_info_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *mob_id, unsigned char *progress);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mission_info(sd, mob_id, progress);
	}
	if( HPMHooks.count.HP_clif_mission_info_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int mob_id, unsigned char progress);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mission_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mission_info_post[hIndex].func;
			postHookFunc(sd, mob_id, progress);
		}
	}
	return;
}
void HP_clif_feel_hate_reset(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_feel_hate_reset_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.feel_hate_reset(sd);
	}
	if( HPMHooks.count.HP_clif_feel_hate_reset_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_feel_hate_reset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_feel_hate_reset_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_partytickack(struct map_session_data *sd, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_partytickack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, bool *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.partytickack(sd, flag);
	}
	if( HPMHooks.count.HP_clif_partytickack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partytickack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_partytickack_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_equiptickack(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_equiptickack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.equiptickack(sd, flag);
	}
	if( HPMHooks.count.HP_clif_equiptickack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equiptickack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_equiptickack_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_viewequip_ack(struct map_session_data *sd, struct map_session_data *tsd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_viewequip_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.viewequip_ack(sd, tsd);
	}
	if( HPMHooks.count.HP_clif_viewequip_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_viewequip_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_viewequip_ack_post[hIndex].func;
			postHookFunc(sd, tsd);
		}
	}
	return;
}
void HP_clif_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.equpcheckbox(sd);
	}
	if( HPMHooks.count.HP_clif_equpcheckbox_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_equpcheckbox_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_equpcheckbox_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_displayexp(struct map_session_data *sd, unsigned int exp, char type, bool is_quest) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_displayexp_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *exp, char *type, bool *is_quest);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.displayexp(sd, exp, type, is_quest);
	}
	if( HPMHooks.count.HP_clif_displayexp_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int exp, char type, bool is_quest);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_displayexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_displayexp_post[hIndex].func;
			postHookFunc(sd, exp, type, is_quest);
		}
	}
	return;
}
void HP_clif_font(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_font_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.font(sd);
	}
	if( HPMHooks.count.HP_clif_font_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_font_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_font_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_progressbar(struct map_session_data *sd, unsigned int color, unsigned int second) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.progressbar(sd, color, second);
	}
	if( HPMHooks.count.HP_clif_progressbar_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int color, unsigned int second);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_progressbar_post[hIndex].func;
			postHookFunc(sd, color, second);
		}
	}
	return;
}
void HP_clif_progressbar_abort(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_progressbar_abort_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.progressbar_abort(sd);
	}
	if( HPMHooks.count.HP_clif_progressbar_abort_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_progressbar_abort_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_progressbar_abort_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_showdigit(struct map_session_data *sd, unsigned char type, int value) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_showdigit_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *type, int *value);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.showdigit(sd, type, value);
	}
	if( HPMHooks.count.HP_clif_showdigit_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char type, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showdigit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_showdigit_post[hIndex].func;
			postHookFunc(sd, type, value);
		}
	}
	return;
}
int HP_clif_elementalconverter_list(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.elementalconverter_list(sd);
	}
	if( HPMHooks.count.HP_clif_elementalconverter_list_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elementalconverter_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_elementalconverter_list_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_clif_spellbook_list(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.spellbook_list(sd);
	}
	if( HPMHooks.count.HP_clif_spellbook_list_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spellbook_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_spellbook_list_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_clif_magicdecoy_list(struct map_session_data *sd, uint16 skill_lv, short x, short y) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.magicdecoy_list(sd, skill_lv, x, y);
	}
	if( HPMHooks.count.HP_clif_magicdecoy_list_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_lv, short x, short y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_magicdecoy_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_magicdecoy_list_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_lv, x, y);
		}
	}
	return retVal___;
}
int HP_clif_poison_list(struct map_session_data *sd, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.poison_list(sd, skill_lv);
	}
	if( HPMHooks.count.HP_clif_poison_list_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_poison_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_poison_list_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_lv);
		}
	}
	return retVal___;
}
int HP_clif_autoshadowspell_list(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.autoshadowspell_list(sd);
	}
	if( HPMHooks.count.HP_clif_autoshadowspell_list_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_autoshadowspell_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_autoshadowspell_list_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_clif_skill_itemlistwindow(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.skill_itemlistwindow(sd, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_clif_skill_itemlistwindow_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_itemlistwindow_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_itemlistwindow_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv);
		}
	}
	return retVal___;
}
void HP_clif_sc_load(struct block_list *bl, int tid, enum send_target target, int type, int val1, int val2, int val3) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sc_load_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *tid, enum send_target *target, int *type, int *val1, int *val2, int *val3);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sc_load(bl, tid, target, type, val1, val2, val3);
	}
	if( HPMHooks.count.HP_clif_sc_load_post ) {
		void (*postHookFunc) (struct block_list *bl, int tid, enum send_target target, int type, int val1, int val2, int val3);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_load_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sc_load_post[hIndex].func;
			postHookFunc(bl, tid, target, type, val1, val2, val3);
		}
	}
	return;
}
void HP_clif_sc_continue(struct block_list *bl, int tid, enum send_target target, int type, int val1, int val2, int val3) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sc_continue_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_continue_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_sc_continue_pre[hIndex].func;
			preHookFunc(&bl, &tid, &target, &type, &val1, &val2, &val3);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sc_continue(bl, tid, target, type, val1, val2, val3);
	}
	if( HPMHooks.count.HP_clif_sc_continue_post ) {
		void (*postHookFunc) (struct block_list *bl, int tid, enum send_target target, int type, int val1, int val2, int val3);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_continue_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sc_continue_post[hIndex].func;
			postHookFunc(bl, tid, target, type, val1, val2, val3);
		}
	}
	return;
}
void HP_clif_sc_end(struct block_list *bl, int tid, enum send_target target, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sc_end_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *tid, enum send_target *target, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sc_end(bl, tid, target, type);
	}
	if( HPMHooks.count.HP_clif_sc_end_post ) {
		void (*postHookFunc) (struct block_list *bl, int tid, enum send_target target, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sc_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sc_end_post[hIndex].func;
			postHookFunc(bl, tid, target, type);
		}
	}
	return;
}
void HP_clif_initialstatus(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_initialstatus_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.initialstatus(sd);
	}
	if( HPMHooks.count.HP_clif_initialstatus_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_initialstatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_initialstatus_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_cooldown_list(int fd, struct skill_cd *cd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cooldown_list_pre ) {
		void (*preHookFunc) (int *fd, struct skill_cd **cd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cooldown_list(fd, cd);
	}
	if( HPMHooks.count.HP_clif_cooldown_list_post ) {
		void (*postHookFunc) (int fd, struct skill_cd *cd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cooldown_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cooldown_list_post[hIndex].func;
			postHookFunc(fd, cd);
		}
	}
	return;
}
void HP_clif_updatestatus(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_updatestatus_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.updatestatus(sd, type);
	}
	if( HPMHooks.count.HP_clif_updatestatus_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_updatestatus_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_changestatus(struct map_session_data *sd, int type, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changestatus_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changestatus(sd, type, val);
	}
	if( HPMHooks.count.HP_clif_changestatus_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changestatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changestatus_post[hIndex].func;
			postHookFunc(sd, type, val);
		}
	}
	return;
}
void HP_clif_statusupack(struct map_session_data *sd, int type, int ok, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_statusupack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type, int *ok, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.statusupack(sd, type, ok, val);
	}
	if( HPMHooks.count.HP_clif_statusupack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type, int ok, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_statusupack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_statusupack_post[hIndex].func;
			postHookFunc(sd, type, ok, val);
		}
	}
	return;
}
void HP_clif_movetoattack(struct map_session_data *sd, struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_movetoattack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.movetoattack(sd, bl);
	}
	if( HPMHooks.count.HP_clif_movetoattack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_movetoattack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_movetoattack_post[hIndex].func;
			postHookFunc(sd, bl);
		}
	}
	return;
}
void HP_clif_solved_charname(int fd, int charid, const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_solved_charname_pre ) {
		void (*preHookFunc) (int *fd, int *charid, const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.solved_charname(fd, charid, name);
	}
	if( HPMHooks.count.HP_clif_solved_charname_post ) {
		void (*postHookFunc) (int fd, int charid, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_solved_charname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_solved_charname_post[hIndex].func;
			postHookFunc(fd, charid, name);
		}
	}
	return;
}
void HP_clif_charnameupdate(struct map_session_data *ssd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_charnameupdate_pre ) {
		void (*preHookFunc) (struct map_session_data **ssd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.charnameupdate(ssd);
	}
	if( HPMHooks.count.HP_clif_charnameupdate_post ) {
		void (*postHookFunc) (struct map_session_data *ssd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charnameupdate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_charnameupdate_post[hIndex].func;
			postHookFunc(ssd);
		}
	}
	return;
}
int HP_clif_delayquit(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.delayquit(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_clif_delayquit_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delayquit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_delayquit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_clif_getareachar_pc(struct map_session_data *sd, struct map_session_data *dstsd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_getareachar_pc_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **dstsd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.getareachar_pc(sd, dstsd);
	}
	if( HPMHooks.count.HP_clif_getareachar_pc_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *dstsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_getareachar_pc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_getareachar_pc_post[hIndex].func;
			postHookFunc(sd, dstsd);
		}
	}
	return;
}
void HP_clif_disconnect_ack(struct map_session_data *sd, short result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_disconnect_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *result);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.disconnect_ack(sd, result);
	}
	if( HPMHooks.count.HP_clif_disconnect_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disconnect_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_disconnect_ack_post[hIndex].func;
			postHookFunc(sd, result);
		}
	}
	return;
}
void HP_clif_PVPInfo(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PVPInfo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PVPInfo(sd);
	}
	if( HPMHooks.count.HP_clif_PVPInfo_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PVPInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PVPInfo_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_blacksmith(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_blacksmith_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.blacksmith(sd);
	}
	if( HPMHooks.count.HP_clif_blacksmith_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_blacksmith_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_blacksmith_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_alchemist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_alchemist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.alchemist(sd);
	}
	if( HPMHooks.count.HP_clif_alchemist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_alchemist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_alchemist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_taekwon(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_taekwon_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.taekwon(sd);
	}
	if( HPMHooks.count.HP_clif_taekwon_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_taekwon_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_taekwon_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_ranking_pk(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_ranking_pk_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.ranking_pk(sd);
	}
	if( HPMHooks.count.HP_clif_ranking_pk_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ranking_pk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_ranking_pk_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_quitsave(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_quitsave_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.quitsave(fd, sd);
	}
	if( HPMHooks.count.HP_clif_quitsave_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quitsave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_quitsave_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_misceffect(struct block_list *bl, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_misceffect_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.misceffect(bl, type);
	}
	if( HPMHooks.count.HP_clif_misceffect_post ) {
		void (*postHookFunc) (struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_misceffect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_misceffect_post[hIndex].func;
			postHookFunc(bl, type);
		}
	}
	return;
}
void HP_clif_changeoption(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changeoption_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changeoption(bl);
	}
	if( HPMHooks.count.HP_clif_changeoption_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changeoption_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_changeoption2(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changeoption2_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changeoption2(bl);
	}
	if( HPMHooks.count.HP_clif_changeoption2_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changeoption2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changeoption2_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_emotion(struct block_list *bl, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_emotion_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.emotion(bl, type);
	}
	if( HPMHooks.count.HP_clif_emotion_post ) {
		void (*postHookFunc) (struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_emotion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_emotion_post[hIndex].func;
			postHookFunc(bl, type);
		}
	}
	return;
}
void HP_clif_talkiebox(struct block_list *bl, const char *talkie) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_talkiebox_pre ) {
		void (*preHookFunc) (struct block_list **bl, const char **talkie);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.talkiebox(bl, talkie);
	}
	if( HPMHooks.count.HP_clif_talkiebox_post ) {
		void (*postHookFunc) (struct block_list *bl, const char *talkie);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_talkiebox_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_talkiebox_post[hIndex].func;
			postHookFunc(bl, talkie);
		}
	}
	return;
}
void HP_clif_wedding_effect(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_wedding_effect_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.wedding_effect(bl);
	}
	if( HPMHooks.count.HP_clif_wedding_effect_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wedding_effect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_wedding_effect_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_divorced(struct map_session_data *sd, const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_divorced_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.divorced(sd, name);
	}
	if( HPMHooks.count.HP_clif_divorced_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_divorced_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_divorced_post[hIndex].func;
			postHookFunc(sd, name);
		}
	}
	return;
}
void HP_clif_callpartner(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_callpartner_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.callpartner(sd);
	}
	if( HPMHooks.count.HP_clif_callpartner_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_callpartner_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_callpartner_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_clif_skill_damage(struct block_list *src, struct block_list *dst, int64 tick, int sdelay, int ddelay, int64 damage, int div, uint16 skill_id, uint16 skill_lv, int type) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.skill_damage(src, dst, tick, sdelay, ddelay, damage, div, skill_id, skill_lv, type);
	}
	if( HPMHooks.count.HP_clif_skill_damage_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, int64 tick, int sdelay, int ddelay, int64 damage, int div, uint16 skill_id, uint16 skill_lv, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, dst, tick, sdelay, ddelay, damage, div, skill_id, skill_lv, type);
		}
	}
	return retVal___;
}
int HP_clif_skill_nodamage(struct block_list *src, struct block_list *dst, uint16 skill_id, int heal, int fail) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.skill_nodamage(src, dst, skill_id, heal, fail);
	}
	if( HPMHooks.count.HP_clif_skill_nodamage_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *dst, uint16 skill_id, int heal, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_nodamage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_nodamage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, dst, skill_id, heal, fail);
		}
	}
	return retVal___;
}
void HP_clif_skill_poseffect(struct block_list *src, uint16 skill_id, int val, int x, int y, int64 tick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skill_poseffect_pre ) {
		void (*preHookFunc) (struct block_list **src, uint16 *skill_id, int *val, int *x, int *y, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_poseffect(src, skill_id, val, x, y, tick);
	}
	if( HPMHooks.count.HP_clif_skill_poseffect_post ) {
		void (*postHookFunc) (struct block_list *src, uint16 skill_id, int val, int x, int y, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_poseffect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_poseffect_post[hIndex].func;
			postHookFunc(src, skill_id, val, x, y, tick);
		}
	}
	return;
}
void HP_clif_skill_estimation(struct map_session_data *sd, struct block_list *dst) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skill_estimation_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct block_list **dst);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_estimation(sd, dst);
	}
	if( HPMHooks.count.HP_clif_skill_estimation_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct block_list *dst);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_estimation_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_estimation_post[hIndex].func;
			postHookFunc(sd, dst);
		}
	}
	return;
}
void HP_clif_skill_warppoint(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, unsigned short map1, unsigned short map2, unsigned short map3, unsigned short map4) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skill_warppoint_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv, unsigned short *map1, unsigned short *map2, unsigned short *map3, unsigned short *map4);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skill_warppoint(sd, skill_id, skill_lv, map1, map2, map3, map4);
	}
	if( HPMHooks.count.HP_clif_skill_warppoint_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, unsigned short map1, unsigned short map2, unsigned short map3, unsigned short map4);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skill_warppoint_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skill_warppoint_post[hIndex].func;
			postHookFunc(sd, skill_id, skill_lv, map1, map2, map3, map4);
		}
	}
	return;
}
void HP_clif_useskill(struct block_list *bl, int src_id, int dst_id, int dst_x, int dst_y, uint16 skill_id, uint16 skill_lv, int casttime) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_useskill_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *src_id, int *dst_id, int *dst_x, int *dst_y, uint16 *skill_id, uint16 *skill_lv, int *casttime);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_useskill_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_useskill_pre[hIndex].func;
			preHookFunc(&bl, &src_id, &dst_id, &dst_x, &dst_y, &skill_id, &skill_lv, &casttime);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.useskill(bl, src_id, dst_id, dst_x, dst_y, skill_id, skill_lv, casttime);
	}
	if( HPMHooks.count.HP_clif_useskill_post ) {
		void (*postHookFunc) (struct block_list *bl, int src_id, int dst_id, int dst_x, int dst_y, uint16 skill_id, uint16 skill_lv, int casttime);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_useskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_useskill_post[hIndex].func;
			postHookFunc(bl, src_id, dst_id, dst_x, dst_y, skill_id, skill_lv, casttime);
		}
	}
	return;
}
void HP_clif_produce_effect(struct map_session_data *sd, int flag, int nameid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_produce_effect_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag, int *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.produce_effect(sd, flag, nameid);
	}
	if( HPMHooks.count.HP_clif_produce_effect_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_produce_effect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_produce_effect_post[hIndex].func;
			postHookFunc(sd, flag, nameid);
		}
	}
	return;
}
void HP_clif_devotion(struct block_list *src, struct map_session_data *tsd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_devotion_pre ) {
		void (*preHookFunc) (struct block_list **src, struct map_session_data **tsd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.devotion(src, tsd);
	}
	if( HPMHooks.count.HP_clif_devotion_post ) {
		void (*postHookFunc) (struct block_list *src, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_devotion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_devotion_post[hIndex].func;
			postHookFunc(src, tsd);
		}
	}
	return;
}
void HP_clif_spiritball(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_spiritball_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.spiritball(bl);
	}
	if( HPMHooks.count.HP_clif_spiritball_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_spiritball_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_spiritball_single(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_spiritball_single_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.spiritball_single(fd, sd);
	}
	if( HPMHooks.count.HP_clif_spiritball_single_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritball_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_spiritball_single_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_bladestop(struct block_list *src, int dst_id, int active) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bladestop_pre ) {
		void (*preHookFunc) (struct block_list **src, int *dst_id, int *active);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bladestop(src, dst_id, active);
	}
	if( HPMHooks.count.HP_clif_bladestop_post ) {
		void (*postHookFunc) (struct block_list *src, int dst_id, int active);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bladestop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bladestop_post[hIndex].func;
			postHookFunc(src, dst_id, active);
		}
	}
	return;
}
void HP_clif_mvp_effect(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mvp_effect_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mvp_effect(sd);
	}
	if( HPMHooks.count.HP_clif_mvp_effect_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mvp_effect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mvp_effect_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_heal(int fd, int type, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_heal_pre ) {
		void (*preHookFunc) (int *fd, int *type, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.heal(fd, type, val);
	}
	if( HPMHooks.count.HP_clif_heal_post ) {
		void (*postHookFunc) (int fd, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_heal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_heal_post[hIndex].func;
			postHookFunc(fd, type, val);
		}
	}
	return;
}
void HP_clif_resurrection(struct block_list *bl, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_resurrection_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.resurrection(bl, type);
	}
	if( HPMHooks.count.HP_clif_resurrection_post ) {
		void (*postHookFunc) (struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_resurrection_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_resurrection_post[hIndex].func;
			postHookFunc(bl, type);
		}
	}
	return;
}
void HP_clif_refine(int fd, int fail, int index, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_refine_pre ) {
		void (*preHookFunc) (int *fd, int *fail, int *index, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.refine(fd, fail, index, val);
	}
	if( HPMHooks.count.HP_clif_refine_post ) {
		void (*postHookFunc) (int fd, int fail, int index, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_refine_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_refine_post[hIndex].func;
			postHookFunc(fd, fail, index, val);
		}
	}
	return;
}
void HP_clif_weather(int16 m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_weather_pre ) {
		void (*preHookFunc) (int16 *m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.weather(m);
	}
	if( HPMHooks.count.HP_clif_weather_post ) {
		void (*postHookFunc) (int16 m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_weather_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_clif_specialeffect(struct block_list *bl, int type, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_specialeffect_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *type, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.specialeffect(bl, type, target);
	}
	if( HPMHooks.count.HP_clif_specialeffect_post ) {
		void (*postHookFunc) (struct block_list *bl, int type, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_specialeffect_post[hIndex].func;
			postHookFunc(bl, type, target);
		}
	}
	return;
}
void HP_clif_specialeffect_single(struct block_list *bl, int type, int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_specialeffect_single_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *type, int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.specialeffect_single(bl, type, fd);
	}
	if( HPMHooks.count.HP_clif_specialeffect_single_post ) {
		void (*postHookFunc) (struct block_list *bl, int type, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_specialeffect_single_post[hIndex].func;
			postHookFunc(bl, type, fd);
		}
	}
	return;
}
void HP_clif_specialeffect_value(struct block_list *bl, int effect_id, int num, send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_specialeffect_value_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *effect_id, int *num, send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.specialeffect_value(bl, effect_id, num, target);
	}
	if( HPMHooks.count.HP_clif_specialeffect_value_post ) {
		void (*postHookFunc) (struct block_list *bl, int effect_id, int num, send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_specialeffect_value_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_specialeffect_value_post[hIndex].func;
			postHookFunc(bl, effect_id, num, target);
		}
	}
	return;
}
void HP_clif_millenniumshield(struct 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.millenniumshield(bl, shields);
	}
	if( HPMHooks.count.HP_clif_millenniumshield_post ) {
		void (*postHookFunc) (struct block_list *bl, short shields);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_millenniumshield_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_millenniumshield_post[hIndex].func;
			postHookFunc(bl, shields);
		}
	}
	return;
}
void HP_clif_spiritcharm(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_spiritcharm_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritcharm_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_spiritcharm_pre[hIndex].func;
			preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.spiritcharm(sd);
	}
	if( HPMHooks.count.HP_clif_spiritcharm_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_spiritcharm_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_spiritcharm_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_charm_single(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_charm_single_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.charm_single(fd, sd);
	}
	if( HPMHooks.count.HP_clif_charm_single_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_charm_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_charm_single_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_snap(struct block_list *bl, short x, short y) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_snap_pre ) {
		void (*preHookFunc) (struct block_list **bl, short *x, short *y);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.snap(bl, x, y);
	}
	if( HPMHooks.count.HP_clif_snap_post ) {
		void (*postHookFunc) (struct block_list *bl, short x, short y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_snap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_snap_post[hIndex].func;
			postHookFunc(bl, x, y);
		}
	}
	return;
}
void HP_clif_weather_check(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_weather_check_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.weather_check(sd);
	}
	if( HPMHooks.count.HP_clif_weather_check_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_weather_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_weather_check_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_playBGM(struct map_session_data *sd, const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_playBGM_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.playBGM(sd, name);
	}
	if( HPMHooks.count.HP_clif_playBGM_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_playBGM_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_playBGM_post[hIndex].func;
			postHookFunc(sd, name);
		}
	}
	return;
}
void HP_clif_soundeffect(struct map_session_data *sd, struct block_list *bl, const char *name, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_soundeffect_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct block_list **bl, const char **name, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.soundeffect(sd, bl, name, type);
	}
	if( HPMHooks.count.HP_clif_soundeffect_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl, const char *name, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_soundeffect_post[hIndex].func;
			postHookFunc(sd, bl, name, type);
		}
	}
	return;
}
void HP_clif_soundeffectall(struct block_list *bl, const char *name, int type, enum send_target coverage) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_soundeffectall_pre ) {
		void (*preHookFunc) (struct block_list **bl, const char **name, int *type, enum send_target *coverage);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.soundeffectall(bl, name, type, coverage);
	}
	if( HPMHooks.count.HP_clif_soundeffectall_post ) {
		void (*postHookFunc) (struct block_list *bl, const char *name, int type, enum send_target coverage);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_soundeffectall_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_soundeffectall_post[hIndex].func;
			postHookFunc(bl, name, type, coverage);
		}
	}
	return;
}
void HP_clif_GlobalMessage(struct block_list *bl, const char *message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_GlobalMessage_pre ) {
		void (*preHookFunc) (struct block_list **bl, const char **message);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.GlobalMessage(bl, message);
	}
	if( HPMHooks.count.HP_clif_GlobalMessage_post ) {
		void (*postHookFunc) (struct block_list *bl, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GlobalMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_GlobalMessage_post[hIndex].func;
			postHookFunc(bl, message);
		}
	}
	return;
}
void HP_clif_createchat(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_createchat_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.createchat(sd, flag);
	}
	if( HPMHooks.count.HP_clif_createchat_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_createchat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_createchat_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_dispchat(struct chat_data *cd, int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_dispchat_pre ) {
		void (*preHookFunc) (struct chat_data **cd, int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.dispchat(cd, fd);
	}
	if( HPMHooks.count.HP_clif_dispchat_post ) {
		void (*postHookFunc) (struct chat_data *cd, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dispchat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_dispchat_post[hIndex].func;
			postHookFunc(cd, fd);
		}
	}
	return;
}
void HP_clif_joinchatfail(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_joinchatfail_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.joinchatfail(sd, flag);
	}
	if( HPMHooks.count.HP_clif_joinchatfail_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatfail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_joinchatfail_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_joinchatok(struct map_session_data *sd, struct chat_data *cd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_joinchatok_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct chat_data **cd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.joinchatok(sd, cd);
	}
	if( HPMHooks.count.HP_clif_joinchatok_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct chat_data *cd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_joinchatok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_joinchatok_post[hIndex].func;
			postHookFunc(sd, cd);
		}
	}
	return;
}
void HP_clif_addchat(struct chat_data *cd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_addchat_pre ) {
		void (*preHookFunc) (struct chat_data **cd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.addchat(cd, sd);
	}
	if( HPMHooks.count.HP_clif_addchat_post ) {
		void (*postHookFunc) (struct chat_data *cd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addchat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_addchat_post[hIndex].func;
			postHookFunc(cd, sd);
		}
	}
	return;
}
void HP_clif_changechatowner(struct chat_data *cd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changechatowner_pre ) {
		void (*preHookFunc) (struct chat_data **cd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changechatowner(cd, sd);
	}
	if( HPMHooks.count.HP_clif_changechatowner_post ) {
		void (*postHookFunc) (struct chat_data *cd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatowner_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changechatowner_post[hIndex].func;
			postHookFunc(cd, sd);
		}
	}
	return;
}
void HP_clif_clearchat(struct chat_data *cd, int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_clearchat_pre ) {
		void (*preHookFunc) (struct chat_data **cd, int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.clearchat(cd, fd);
	}
	if( HPMHooks.count.HP_clif_clearchat_post ) {
		void (*postHookFunc) (struct chat_data *cd, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_clearchat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_clearchat_post[hIndex].func;
			postHookFunc(cd, fd);
		}
	}
	return;
}
void HP_clif_leavechat(struct chat_data *cd, struct map_session_data *sd, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_leavechat_pre ) {
		void (*preHookFunc) (struct chat_data **cd, struct map_session_data **sd, bool *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.leavechat(cd, sd, flag);
	}
	if( HPMHooks.count.HP_clif_leavechat_post ) {
		void (*postHookFunc) (struct chat_data *cd, struct map_session_data *sd, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_leavechat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_leavechat_post[hIndex].func;
			postHookFunc(cd, sd, flag);
		}
	}
	return;
}
void HP_clif_changechatstatus(struct chat_data *cd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_changechatstatus_pre ) {
		void (*preHookFunc) (struct chat_data **cd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.changechatstatus(cd);
	}
	if( HPMHooks.count.HP_clif_changechatstatus_post ) {
		void (*postHookFunc) (struct chat_data *cd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_changechatstatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_changechatstatus_post[hIndex].func;
			postHookFunc(cd);
		}
	}
	return;
}
void HP_clif_wis_message(int fd, const char *nick, const char *mes, int mes_len) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_wis_message_pre ) {
		void (*preHookFunc) (int *fd, const char **nick, const char **mes, int *mes_len);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.wis_message(fd, nick, mes, mes_len);
	}
	if( HPMHooks.count.HP_clif_wis_message_post ) {
		void (*postHookFunc) (int fd, const char *nick, const char *mes, int mes_len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_wis_message_post[hIndex].func;
			postHookFunc(fd, nick, mes, mes_len);
		}
	}
	return;
}
void HP_clif_wis_end(int fd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_wis_end_pre ) {
		void (*preHookFunc) (int *fd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.wis_end(fd, flag);
	}
	if( HPMHooks.count.HP_clif_wis_end_post ) {
		void (*postHookFunc) (int fd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wis_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_wis_end_post[hIndex].func;
			postHookFunc(fd, flag);
		}
	}
	return;
}
void HP_clif_disp_message(struct block_list *src, const char *mes, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_disp_message_pre ) {
		void (*preHookFunc) (struct block_list **src, const char **mes, 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, &target);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.disp_message(src, mes, target);
	}
	if( HPMHooks.count.HP_clif_disp_message_post ) {
		void (*postHookFunc) (struct block_list *src, const char *mes, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_disp_message_post[hIndex].func;
			postHookFunc(src, mes, target);
		}
	}
	return;
}
void HP_clif_broadcast(struct block_list *bl, const char *mes, int len, int type, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_broadcast_pre ) {
		void (*preHookFunc) (struct block_list **bl, const char **mes, int *len, int *type, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.broadcast(bl, mes, len, type, target);
	}
	if( HPMHooks.count.HP_clif_broadcast_post ) {
		void (*postHookFunc) (struct block_list *bl, const char *mes, int len, int type, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_broadcast_post[hIndex].func;
			postHookFunc(bl, mes, len, type, target);
		}
	}
	return;
}
void HP_clif_broadcast2(struct block_list *bl, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_broadcast2_pre ) {
		void (*preHookFunc) (struct block_list **bl, const char **mes, int *len, unsigned 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.broadcast2(bl, mes, len, fontColor, fontType, fontSize, fontAlign, fontY, target);
	}
	if( HPMHooks.count.HP_clif_broadcast2_post ) {
		void (*postHookFunc) (struct block_list *bl, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_broadcast2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_broadcast2_post[hIndex].func;
			postHookFunc(bl, mes, len, fontColor, fontType, fontSize, fontAlign, fontY, target);
		}
	}
	return;
}
void HP_clif_messagecolor_self(int fd, uint32 color, const char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_messagecolor_self_pre ) {
		void (*preHookFunc) (int *fd, uint32 *color, const char **msg);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_self_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_messagecolor_self_pre[hIndex].func;
			preHookFunc(&fd, &color, &msg);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.messagecolor_self(fd, color, msg);
	}
	if( HPMHooks.count.HP_clif_messagecolor_self_post ) {
		void (*postHookFunc) (int fd, uint32 color, const char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_self_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_messagecolor_self_post[hIndex].func;
			postHookFunc(fd, color, msg);
		}
	}
	return;
}
void HP_clif_messagecolor(struct block_list *bl, uint32 color, const char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_messagecolor_pre ) {
		void (*preHookFunc) (struct block_list **bl, uint32 *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.messagecolor(bl, color, msg);
	}
	if( HPMHooks.count.HP_clif_messagecolor_post ) {
		void (*postHookFunc) (struct block_list *bl, uint32 color, const char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messagecolor_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_messagecolor_post[hIndex].func;
			postHookFunc(bl, color, msg);
		}
	}
	return;
}
void HP_clif_disp_overhead(struct block_list *bl, const char *mes) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_disp_overhead_pre ) {
		void (*preHookFunc) (struct block_list **bl, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.disp_overhead(bl, mes);
	}
	if( HPMHooks.count.HP_clif_disp_overhead_post ) {
		void (*postHookFunc) (struct block_list *bl, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_disp_overhead_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_disp_overhead_post[hIndex].func;
			postHookFunc(bl, mes);
		}
	}
	return;
}
void HP_clif_msgtable(struct map_session_data *sd, unsigned short msg_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_msgtable_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short *msg_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_msgtable_pre[hIndex].func;
			preHookFunc(&sd, &msg_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.msgtable(sd, msg_id);
	}
	if( HPMHooks.count.HP_clif_msgtable_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short msg_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_msgtable_post[hIndex].func;
			postHookFunc(sd, msg_id);
		}
	}
	return;
}
void HP_clif_msgtable_num(struct map_session_data *sd, unsigned short msg_id, int value) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_msgtable_num_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short *msg_id, int *value);
		*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(&sd, &msg_id, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.msgtable_num(sd, msg_id, value);
	}
	if( HPMHooks.count.HP_clif_msgtable_num_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short msg_id, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_msgtable_num_post[hIndex].func;
			postHookFunc(sd, msg_id, value);
		}
	}
	return;
}
void HP_clif_msgtable_skill(struct map_session_data *sd, uint16 skill_id, int msg_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_msgtable_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_msgtable_skill_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_msgtable_skill_pre[hIndex].func;
			preHookFunc(&sd, &skill_id, &msg_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.msgtable_skill(sd, skill_id, msg_id);
	}
	if( HPMHooks.count.HP_clif_msgtable_skill_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, int msg_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_msgtable_skill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_msgtable_skill_post[hIndex].func;
			postHookFunc(sd, skill_id, msg_id);
		}
	}
	return;
}
void HP_clif_message(const int fd, const char *mes) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_message_pre ) {
		void (*preHookFunc) (const int *fd, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.message(fd, mes);
	}
	if( HPMHooks.count.HP_clif_message_post ) {
		void (*postHookFunc) (const int fd, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_message_post[hIndex].func;
			postHookFunc(fd, mes);
		}
	}
	return;
}
void HP_clif_messageln(const int fd, const char *mes) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_messageln_pre ) {
		void (*preHookFunc) (const int *fd, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.messageln(fd, mes);
	}
	if( HPMHooks.count.HP_clif_messageln_post ) {
		void (*postHookFunc) (const int fd, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_messageln_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_messageln_post[hIndex].func;
			postHookFunc(fd, mes);
		}
	}
	return;
}
const char* HP_clif_process_chat_message(struct map_session_data *sd, const struct packet_chat_message *packet, char *out_buf, int out_buflen) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_clif_process_chat_message_pre ) {
		const char* (*preHookFunc) (struct map_session_data **sd, const struct packet_chat_message **packet, char **out_buf, int *out_buflen);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_chat_message_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_process_chat_message_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &packet, &out_buf, &out_buflen);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.process_chat_message(sd, packet, out_buf, out_buflen);
	}
	if( HPMHooks.count.HP_clif_process_chat_message_post ) {
		const char* (*postHookFunc) (const char* retVal___, struct map_session_data *sd, const struct packet_chat_message *packet, char *out_buf, int out_buflen);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_chat_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_process_chat_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, packet, out_buf, out_buflen);
		}
	}
	return retVal___;
}
bool HP_clif_process_whisper_message(struct map_session_data *sd, const struct packet_whisper_message *packet, char *out_name, char *out_message, int out_messagelen) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_clif_process_whisper_message_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, const struct packet_whisper_message **packet, char **out_name, char **out_message, int *out_messagelen);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_whisper_message_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_process_whisper_message_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &packet, &out_name, &out_message, &out_messagelen);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.process_whisper_message(sd, packet, out_name, out_message, out_messagelen);
	}
	if( HPMHooks.count.HP_clif_process_whisper_message_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const struct packet_whisper_message *packet, char *out_name, char *out_message, int out_messagelen);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_process_whisper_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_process_whisper_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, packet, out_name, out_message, out_messagelen);
		}
	}
	return retVal___;
}
void HP_clif_wisexin(struct map_session_data *sd, int type, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_wisexin_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.wisexin(sd, type, flag);
	}
	if( HPMHooks.count.HP_clif_wisexin_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisexin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_wisexin_post[hIndex].func;
			postHookFunc(sd, type, flag);
		}
	}
	return;
}
void HP_clif_wisall(struct map_session_data *sd, int type, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_wisall_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.wisall(sd, type, flag);
	}
	if( HPMHooks.count.HP_clif_wisall_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_wisall_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_wisall_post[hIndex].func;
			postHookFunc(sd, type, flag);
		}
	}
	return;
}
void HP_clif_PMIgnoreList(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PMIgnoreList_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PMIgnoreList(sd);
	}
	if( HPMHooks.count.HP_clif_PMIgnoreList_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PMIgnoreList_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PMIgnoreList_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.ShowScript(bl, message);
	}
	if( HPMHooks.count.HP_clif_ShowScript_post ) {
		void (*postHookFunc) (struct block_list *bl, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ShowScript_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_ShowScript_post[hIndex].func;
			postHookFunc(bl, message);
		}
	}
	return;
}
void HP_clif_traderequest(struct map_session_data *sd, const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_traderequest_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.traderequest(sd, name);
	}
	if( HPMHooks.count.HP_clif_traderequest_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_traderequest_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_traderequest_post[hIndex].func;
			postHookFunc(sd, name);
		}
	}
	return;
}
void HP_clif_tradestart(struct map_session_data *sd, uint8 type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_tradestart_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, uint8 *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.tradestart(sd, type);
	}
	if( HPMHooks.count.HP_clif_tradestart_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint8 type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradestart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_tradestart_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_tradeadditem(struct map_session_data *sd, struct map_session_data *tsd, int index, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_tradeadditem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd, int *index, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.tradeadditem(sd, tsd, index, amount);
	}
	if( HPMHooks.count.HP_clif_tradeadditem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeadditem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_tradeadditem_post[hIndex].func;
			postHookFunc(sd, tsd, index, amount);
		}
	}
	return;
}
void HP_clif_tradeitemok(struct map_session_data *sd, int index, int fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_tradeitemok_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *index, int *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.tradeitemok(sd, index, fail);
	}
	if( HPMHooks.count.HP_clif_tradeitemok_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int index, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeitemok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_tradeitemok_post[hIndex].func;
			postHookFunc(sd, index, fail);
		}
	}
	return;
}
void HP_clif_tradedeal_lock(struct map_session_data *sd, int fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_tradedeal_lock_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.tradedeal_lock(sd, fail);
	}
	if( HPMHooks.count.HP_clif_tradedeal_lock_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradedeal_lock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_tradedeal_lock_post[hIndex].func;
			postHookFunc(sd, fail);
		}
	}
	return;
}
void HP_clif_tradecancelled(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_tradecancelled_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.tradecancelled(sd);
	}
	if( HPMHooks.count.HP_clif_tradecancelled_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecancelled_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_tradecancelled_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_tradecompleted(struct map_session_data *sd, int fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_tradecompleted_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.tradecompleted(sd, fail);
	}
	if( HPMHooks.count.HP_clif_tradecompleted_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradecompleted_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_tradecompleted_post[hIndex].func;
			postHookFunc(sd, fail);
		}
	}
	return;
}
void HP_clif_tradeundo(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_tradeundo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.tradeundo(sd);
	}
	if( HPMHooks.count.HP_clif_tradeundo_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_tradeundo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_tradeundo_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_openvendingreq(struct map_session_data *sd, int num) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_openvendingreq_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *num);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.openvendingreq(sd, num);
	}
	if( HPMHooks.count.HP_clif_openvendingreq_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int num);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvendingreq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_openvendingreq_post[hIndex].func;
			postHookFunc(sd, num);
		}
	}
	return;
}
void HP_clif_showvendingboard(struct block_list *bl, const char *message, int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_showvendingboard_pre ) {
		void (*preHookFunc) (struct block_list **bl, const char **message, int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.showvendingboard(bl, message, fd);
	}
	if( HPMHooks.count.HP_clif_showvendingboard_post ) {
		void (*postHookFunc) (struct block_list *bl, const char *message, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_showvendingboard_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_showvendingboard_post[hIndex].func;
			postHookFunc(bl, message, fd);
		}
	}
	return;
}
void HP_clif_closevendingboard(struct block_list *bl, int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_closevendingboard_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.closevendingboard(bl, fd);
	}
	if( HPMHooks.count.HP_clif_closevendingboard_post ) {
		void (*postHookFunc) (struct block_list *bl, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_closevendingboard_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_closevendingboard_post[hIndex].func;
			postHookFunc(bl, fd);
		}
	}
	return;
}
void HP_clif_vendinglist(struct map_session_data *sd, unsigned int id, struct s_vending *vending_list) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_vendinglist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *id, struct s_vending **vending_list);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.vendinglist(sd, id, vending_list);
	}
	if( HPMHooks.count.HP_clif_vendinglist_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int id, struct s_vending *vending_list);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendinglist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_vendinglist_post[hIndex].func;
			postHookFunc(sd, id, vending_list);
		}
	}
	return;
}
void HP_clif_buyvending(struct map_session_data *sd, int index, int amount, int fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyvending_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *index, int *amount, int *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyvending(sd, index, amount, fail);
	}
	if( HPMHooks.count.HP_clif_buyvending_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int index, int amount, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyvending_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyvending_post[hIndex].func;
			postHookFunc(sd, index, amount, fail);
		}
	}
	return;
}
void HP_clif_openvending(struct map_session_data *sd, int id, struct s_vending *vending_list) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_openvending_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *id, struct s_vending **vending_list);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.openvending(sd, id, vending_list);
	}
	if( HPMHooks.count.HP_clif_openvending_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int id, struct s_vending *vending_list);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openvending_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_openvending_post[hIndex].func;
			postHookFunc(sd, id, vending_list);
		}
	}
	return;
}
void HP_clif_vendingreport(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_vendingreport_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *index, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.vendingreport(sd, index, amount);
	}
	if( HPMHooks.count.HP_clif_vendingreport_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_vendingreport_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_vendingreport_post[hIndex].func;
			postHookFunc(sd, index, amount);
		}
	}
	return;
}
void HP_clif_storagelist(struct map_session_data *sd, struct item *items, int items_length) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_storagelist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct item **items, int *items_length);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.storagelist(sd, items, items_length);
	}
	if( HPMHooks.count.HP_clif_storagelist_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct item *items, int items_length);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storagelist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_storagelist_post[hIndex].func;
			postHookFunc(sd, items, items_length);
		}
	}
	return;
}
void HP_clif_updatestorageamount(struct map_session_data *sd, int amount, int max_amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_updatestorageamount_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *amount, int *max_amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.updatestorageamount(sd, amount, max_amount);
	}
	if( HPMHooks.count.HP_clif_updatestorageamount_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int amount, int max_amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_updatestorageamount_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_updatestorageamount_post[hIndex].func;
			postHookFunc(sd, amount, max_amount);
		}
	}
	return;
}
void HP_clif_storageitemadded(struct map_session_data *sd, struct item *i, int index, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_storageitemadded_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct item **i, int *index, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.storageitemadded(sd, i, index, amount);
	}
	if( HPMHooks.count.HP_clif_storageitemadded_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct item *i, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemadded_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_storageitemadded_post[hIndex].func;
			postHookFunc(sd, i, index, amount);
		}
	}
	return;
}
void HP_clif_storageitemremoved(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_storageitemremoved_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *index, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.storageitemremoved(sd, index, amount);
	}
	if( HPMHooks.count.HP_clif_storageitemremoved_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageitemremoved_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_storageitemremoved_post[hIndex].func;
			postHookFunc(sd, index, amount);
		}
	}
	return;
}
void HP_clif_storageclose(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_storageclose_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.storageclose(sd);
	}
	if( HPMHooks.count.HP_clif_storageclose_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_storageclose_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_storageclose_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_skillinfoblock(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skillinfoblock_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skillinfoblock(sd);
	}
	if( HPMHooks.count.HP_clif_skillinfoblock_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfoblock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skillinfoblock_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_skillup(struct map_session_data *sd, uint16 skill_id, int skill_lv, int flag) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skillup(sd, skill_id, skill_lv, flag);
	}
	if( HPMHooks.count.HP_clif_skillup_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, int skill_lv, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skillup_post[hIndex].func;
			postHookFunc(sd, skill_id, skill_lv, flag);
		}
	}
	return;
}
void HP_clif_skillinfo(struct map_session_data *sd, int skill_id, int inf) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_skillinfo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *skill_id, int *inf);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.skillinfo(sd, skill_id, inf);
	}
	if( HPMHooks.count.HP_clif_skillinfo_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int skill_id, int inf);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_skillinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_skillinfo_post[hIndex].func;
			postHookFunc(sd, skill_id, inf);
		}
	}
	return;
}
void HP_clif_addskill(struct map_session_data *sd, int id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_addskill_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.addskill(sd, id);
	}
	if( HPMHooks.count.HP_clif_addskill_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_addskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_addskill_post[hIndex].func;
			postHookFunc(sd, id);
		}
	}
	return;
}
void HP_clif_deleteskill(struct map_session_data *sd, int id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_deleteskill_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.deleteskill(sd, id);
	}
	if( HPMHooks.count.HP_clif_deleteskill_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_deleteskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_deleteskill_post[hIndex].func;
			postHookFunc(sd, id);
		}
	}
	return;
}
void HP_clif_party_created(struct map_session_data *sd, int result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_created_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *result);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_created(sd, result);
	}
	if( HPMHooks.count.HP_clif_party_created_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_created_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_created_post[hIndex].func;
			postHookFunc(sd, result);
		}
	}
	return;
}
void HP_clif_party_member_info(struct party_data *p, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_member_info_pre ) {
		void (*preHookFunc) (struct party_data **p, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_member_info(p, sd);
	}
	if( HPMHooks.count.HP_clif_party_member_info_post ) {
		void (*postHookFunc) (struct party_data *p, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_member_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_member_info_post[hIndex].func;
			postHookFunc(p, sd);
		}
	}
	return;
}
void HP_clif_party_info(struct party_data *p, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_info_pre ) {
		void (*preHookFunc) (struct party_data **p, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_info(p, sd);
	}
	if( HPMHooks.count.HP_clif_party_info_post ) {
		void (*postHookFunc) (struct party_data *p, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_info_post[hIndex].func;
			postHookFunc(p, sd);
		}
	}
	return;
}
void HP_clif_party_invite(struct map_session_data *sd, struct map_session_data *tsd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_invite_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_invite(sd, tsd);
	}
	if( HPMHooks.count.HP_clif_party_invite_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_invite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_invite_post[hIndex].func;
			postHookFunc(sd, tsd);
		}
	}
	return;
}
void HP_clif_party_inviteack(struct map_session_data *sd, const char *nick, int result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_inviteack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **nick, int *result);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_inviteack(sd, nick, result);
	}
	if( HPMHooks.count.HP_clif_party_inviteack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *nick, int result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_inviteack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_inviteack_post[hIndex].func;
			postHookFunc(sd, nick, result);
		}
	}
	return;
}
void HP_clif_party_option(struct party_data *p, struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_option_pre ) {
		void (*preHookFunc) (struct party_data **p, struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_option(p, sd, flag);
	}
	if( HPMHooks.count.HP_clif_party_option_post ) {
		void (*postHookFunc) (struct party_data *p, struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_option_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_option_post[hIndex].func;
			postHookFunc(p, sd, flag);
		}
	}
	return;
}
void HP_clif_party_withdraw(struct party_data *p, struct map_session_data *sd, int account_id, const char *name, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_withdraw_pre ) {
		void (*preHookFunc) (struct party_data **p, struct map_session_data **sd, int *account_id, const char **name, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_withdraw(p, sd, account_id, name, flag);
	}
	if( HPMHooks.count.HP_clif_party_withdraw_post ) {
		void (*postHookFunc) (struct party_data *p, struct map_session_data *sd, int account_id, const char *name, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_withdraw_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_withdraw_post[hIndex].func;
			postHookFunc(p, sd, account_id, name, flag);
		}
	}
	return;
}
void HP_clif_party_message(struct party_data *p, int account_id, const char *mes, int len) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_message_pre ) {
		void (*preHookFunc) (struct party_data **p, int *account_id, const char **mes, int *len);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_message(p, account_id, mes, len);
	}
	if( HPMHooks.count.HP_clif_party_message_post ) {
		void (*postHookFunc) (struct party_data *p, int account_id, const char *mes, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_message_post[hIndex].func;
			postHookFunc(p, account_id, mes, len);
		}
	}
	return;
}
void HP_clif_party_xy(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_xy_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_xy(sd);
	}
	if( HPMHooks.count.HP_clif_party_xy_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_xy_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_party_xy_single(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_xy_single_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_xy_single(fd, sd);
	}
	if( HPMHooks.count.HP_clif_party_xy_single_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_xy_single_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_party_hp(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_hp_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_hp(sd);
	}
	if( HPMHooks.count.HP_clif_party_hp_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_hp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_hp_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_party_xy_remove(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_xy_remove_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_xy_remove(sd);
	}
	if( HPMHooks.count.HP_clif_party_xy_remove_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_xy_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_xy_remove_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_party_show_picker(struct map_session_data *sd, struct item *item_data) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_party_show_picker_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct item **item_data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.party_show_picker(sd, item_data);
	}
	if( HPMHooks.count.HP_clif_party_show_picker_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct item *item_data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_party_show_picker_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_party_show_picker_post[hIndex].func;
			postHookFunc(sd, item_data);
		}
	}
	return;
}
void HP_clif_partyinvitationstate(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_partyinvitationstate_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.partyinvitationstate(sd);
	}
	if( HPMHooks.count.HP_clif_partyinvitationstate_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_partyinvitationstate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_partyinvitationstate_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_PartyLeaderChanged(struct map_session_data *sd, int prev_leader_aid, int new_leader_aid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyLeaderChanged_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *prev_leader_aid, int *new_leader_aid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyLeaderChanged_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_PartyLeaderChanged_pre[hIndex].func;
			preHookFunc(&sd, &prev_leader_aid, &new_leader_aid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyLeaderChanged(sd, prev_leader_aid, new_leader_aid);
	}
	if( HPMHooks.count.HP_clif_PartyLeaderChanged_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int prev_leader_aid, int new_leader_aid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyLeaderChanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyLeaderChanged_post[hIndex].func;
			postHookFunc(sd, prev_leader_aid, new_leader_aid);
		}
	}
	return;
}
void HP_clif_guild_created(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_created_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_created(sd, flag);
	}
	if( HPMHooks.count.HP_clif_guild_created_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_created_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_created_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_guild_belonginfo(struct map_session_data *sd, struct guild *g) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_belonginfo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct guild **g);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_belonginfo(sd, g);
	}
	if( HPMHooks.count.HP_clif_guild_belonginfo_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct guild *g);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_belonginfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_belonginfo_post[hIndex].func;
			postHookFunc(sd, g);
		}
	}
	return;
}
void HP_clif_guild_masterormember(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_masterormember_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_masterormember(sd);
	}
	if( HPMHooks.count.HP_clif_guild_masterormember_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_masterormember_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_masterormember_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_basicinfo(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_basicinfo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_basicinfo(sd);
	}
	if( HPMHooks.count.HP_clif_guild_basicinfo_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_basicinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_basicinfo_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_allianceinfo(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_allianceinfo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_allianceinfo(sd);
	}
	if( HPMHooks.count.HP_clif_guild_allianceinfo_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_allianceinfo_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_memberlist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_memberlist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_memberlist(sd);
	}
	if( HPMHooks.count.HP_clif_guild_memberlist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_memberlist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_skillinfo(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_skillinfo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_skillinfo(sd);
	}
	if( HPMHooks.count.HP_clif_guild_skillinfo_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_skillinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_skillinfo_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_send_onlineinfo(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_send_onlineinfo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_send_onlineinfo(sd);
	}
	if( HPMHooks.count.HP_clif_guild_send_onlineinfo_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_send_onlineinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_send_onlineinfo_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_memberlogin_notice(struct guild *g, int idx, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_memberlogin_notice_pre ) {
		void (*preHookFunc) (struct guild **g, int *idx, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_memberlogin_notice(g, idx, flag);
	}
	if( HPMHooks.count.HP_clif_guild_memberlogin_notice_post ) {
		void (*postHookFunc) (struct guild *g, int idx, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberlogin_notice_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_memberlogin_notice_post[hIndex].func;
			postHookFunc(g, idx, flag);
		}
	}
	return;
}
void HP_clif_guild_invite(struct map_session_data *sd, struct guild *g) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_invite_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct guild **g);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_invite(sd, g);
	}
	if( HPMHooks.count.HP_clif_guild_invite_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct guild *g);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_invite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_invite_post[hIndex].func;
			postHookFunc(sd, g);
		}
	}
	return;
}
void HP_clif_guild_inviteack(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_inviteack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_inviteack(sd, flag);
	}
	if( HPMHooks.count.HP_clif_guild_inviteack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_inviteack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_inviteack_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_guild_leave(struct map_session_data *sd, const char *name, const char *mes) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_leave_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **name, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_leave(sd, name, mes);
	}
	if( HPMHooks.count.HP_clif_guild_leave_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *name, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_leave_post[hIndex].func;
			postHookFunc(sd, name, mes);
		}
	}
	return;
}
void HP_clif_guild_expulsion(struct map_session_data *sd, const char *name, const char *mes, int account_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_expulsion_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **name, const char **mes, int *account_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_expulsion(sd, name, mes, account_id);
	}
	if( HPMHooks.count.HP_clif_guild_expulsion_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *name, const char *mes, int account_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_expulsion_post[hIndex].func;
			postHookFunc(sd, name, mes, account_id);
		}
	}
	return;
}
void HP_clif_guild_positionchanged(struct guild *g, int idx) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_positionchanged_pre ) {
		void (*preHookFunc) (struct guild **g, int *idx);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_positionchanged(g, idx);
	}
	if( HPMHooks.count.HP_clif_guild_positionchanged_post ) {
		void (*postHookFunc) (struct guild *g, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionchanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_positionchanged_post[hIndex].func;
			postHookFunc(g, idx);
		}
	}
	return;
}
void HP_clif_guild_memberpositionchanged(struct guild *g, int idx) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_memberpositionchanged_pre ) {
		void (*preHookFunc) (struct guild **g, int *idx);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_memberpositionchanged(g, idx);
	}
	if( HPMHooks.count.HP_clif_guild_memberpositionchanged_post ) {
		void (*postHookFunc) (struct guild *g, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_memberpositionchanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_memberpositionchanged_post[hIndex].func;
			postHookFunc(g, idx);
		}
	}
	return;
}
void HP_clif_guild_emblem(struct map_session_data *sd, struct guild *g) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_emblem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct guild **g);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_emblem(sd, g);
	}
	if( HPMHooks.count.HP_clif_guild_emblem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct guild *g);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_emblem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_emblem_post[hIndex].func;
			postHookFunc(sd, g);
		}
	}
	return;
}
void HP_clif_guild_emblem_area(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_emblem_area_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_emblem_area(bl);
	}
	if( HPMHooks.count.HP_clif_guild_emblem_area_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_emblem_area_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_emblem_area_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_clif_guild_notice(struct map_session_data *sd, struct guild *g) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_notice_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct guild **g);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_notice(sd, g);
	}
	if( HPMHooks.count.HP_clif_guild_notice_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct guild *g);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_notice_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_notice_post[hIndex].func;
			postHookFunc(sd, g);
		}
	}
	return;
}
void HP_clif_guild_message(struct guild *g, int account_id, const char *mes, int len) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_message_pre ) {
		void (*preHookFunc) (struct guild **g, int *account_id, const char **mes, int *len);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_message(g, account_id, mes, len);
	}
	if( HPMHooks.count.HP_clif_guild_message_post ) {
		void (*postHookFunc) (struct guild *g, int account_id, const char *mes, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_message_post[hIndex].func;
			postHookFunc(g, account_id, mes, len);
		}
	}
	return;
}
void HP_clif_guild_reqalliance(struct map_session_data *sd, int account_id, const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_reqalliance_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *account_id, const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_reqalliance(sd, account_id, name);
	}
	if( HPMHooks.count.HP_clif_guild_reqalliance_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int account_id, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_reqalliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_reqalliance_post[hIndex].func;
			postHookFunc(sd, account_id, name);
		}
	}
	return;
}
void HP_clif_guild_allianceack(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_allianceack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_allianceack(sd, flag);
	}
	if( HPMHooks.count.HP_clif_guild_allianceack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_allianceack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_allianceack_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_guild_delalliance(struct map_session_data *sd, int guild_id, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_delalliance_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *guild_id, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_delalliance(sd, guild_id, flag);
	}
	if( HPMHooks.count.HP_clif_guild_delalliance_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int guild_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_delalliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_delalliance_post[hIndex].func;
			postHookFunc(sd, guild_id, flag);
		}
	}
	return;
}
void HP_clif_guild_oppositionack(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_oppositionack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_oppositionack(sd, flag);
	}
	if( HPMHooks.count.HP_clif_guild_oppositionack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_oppositionack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_oppositionack_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_guild_broken(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_broken_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_broken(sd, flag);
	}
	if( HPMHooks.count.HP_clif_guild_broken_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_broken_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_broken_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_guild_xy(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_xy_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_xy(sd);
	}
	if( HPMHooks.count.HP_clif_guild_xy_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_xy_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_xy_single(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_xy_single_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_xy_single(fd, sd);
	}
	if( HPMHooks.count.HP_clif_guild_xy_single_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_xy_single_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_guild_xy_remove(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_xy_remove_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_xy_remove(sd);
	}
	if( HPMHooks.count.HP_clif_guild_xy_remove_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_xy_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_xy_remove_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_positionnamelist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_positionnamelist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_positionnamelist(sd);
	}
	if( HPMHooks.count.HP_clif_guild_positionnamelist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positionnamelist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_positionnamelist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_positioninfolist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_positioninfolist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_positioninfolist(sd);
	}
	if( HPMHooks.count.HP_clif_guild_positioninfolist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_positioninfolist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_positioninfolist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_guild_expulsionlist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_guild_expulsionlist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.guild_expulsionlist(sd);
	}
	if( HPMHooks.count.HP_clif_guild_expulsionlist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_guild_expulsionlist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_guild_expulsionlist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
bool HP_clif_validate_emblem(const uint8 *emblem, unsigned long emblem_len) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.validate_emblem(emblem, emblem_len);
	}
	if( HPMHooks.count.HP_clif_validate_emblem_post ) {
		bool (*postHookFunc) (bool retVal___, const uint8 *emblem, unsigned long emblem_len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_validate_emblem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_validate_emblem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, emblem, emblem_len);
		}
	}
	return retVal___;
}
void HP_clif_bg_hp(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bg_hp_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bg_hp(sd);
	}
	if( HPMHooks.count.HP_clif_bg_hp_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_hp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bg_hp_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_bg_xy(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bg_xy_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bg_xy(sd);
	}
	if( HPMHooks.count.HP_clif_bg_xy_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bg_xy_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_bg_xy_remove(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bg_xy_remove_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bg_xy_remove(sd);
	}
	if( HPMHooks.count.HP_clif_bg_xy_remove_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_xy_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bg_xy_remove_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_bg_message(struct battleground_data *bgd, int src_id, const char *name, const char *mes) {
	int 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);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bg_message(bgd, src_id, name, mes);
	}
	if( HPMHooks.count.HP_clif_bg_message_post ) {
		void (*postHookFunc) (struct battleground_data *bgd, int src_id, const char *name, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bg_message_post[hIndex].func;
			postHookFunc(bgd, src_id, name, mes);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bg_updatescore(m);
	}
	if( HPMHooks.count.HP_clif_bg_updatescore_post ) {
		void (*postHookFunc) (int16 m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bg_updatescore_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_clif_bg_updatescore_single(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bg_updatescore_single_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bg_updatescore_single(sd);
	}
	if( HPMHooks.count.HP_clif_bg_updatescore_single_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bg_updatescore_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bg_updatescore_single_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_sendbgemblem_area(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sendbgemblem_area_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sendbgemblem_area(sd);
	}
	if( HPMHooks.count.HP_clif_sendbgemblem_area_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_area_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sendbgemblem_area_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_sendbgemblem_single(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sendbgemblem_single_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sendbgemblem_single(fd, sd);
	}
	if( HPMHooks.count.HP_clif_sendbgemblem_single_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendbgemblem_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sendbgemblem_single_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
int HP_clif_instance(int instance_id, int type, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.instance(instance_id, type, flag);
	}
	if( HPMHooks.count.HP_clif_instance_post ) {
		int (*postHookFunc) (int retVal___, int instance_id, int type, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_instance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, instance_id, type, flag);
		}
	}
	return retVal___;
}
void HP_clif_instance_join(int fd, int instance_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_instance_join_pre ) {
		void (*preHookFunc) (int *fd, int *instance_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.instance_join(fd, instance_id);
	}
	if( HPMHooks.count.HP_clif_instance_join_post ) {
		void (*postHookFunc) (int fd, int instance_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_join_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_instance_join_post[hIndex].func;
			postHookFunc(fd, instance_id);
		}
	}
	return;
}
void HP_clif_instance_leave(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_instance_leave_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.instance_leave(fd);
	}
	if( HPMHooks.count.HP_clif_instance_leave_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_instance_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_instance_leave_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_clif_catch_process(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_catch_process_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.catch_process(sd);
	}
	if( HPMHooks.count.HP_clif_catch_process_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_catch_process_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_catch_process_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_pet_roulette(struct map_session_data *sd, int data) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pet_roulette_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pet_roulette(sd, data);
	}
	if( HPMHooks.count.HP_clif_pet_roulette_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_roulette_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pet_roulette_post[hIndex].func;
			postHookFunc(sd, data);
		}
	}
	return;
}
void HP_clif_sendegg(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_sendegg_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.sendegg(sd);
	}
	if( HPMHooks.count.HP_clif_sendegg_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_sendegg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_sendegg_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_send_petstatus(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_send_petstatus_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.send_petstatus(sd);
	}
	if( HPMHooks.count.HP_clif_send_petstatus_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petstatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_send_petstatus_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_send_petdata(struct map_session_data *sd, struct pet_data *pd, int type, int param) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_send_petdata_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct pet_data **pd, int *type, int *param);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.send_petdata(sd, pd, type, param);
	}
	if( HPMHooks.count.HP_clif_send_petdata_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct pet_data *pd, int type, int param);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_petdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_send_petdata_post[hIndex].func;
			postHookFunc(sd, pd, type, param);
		}
	}
	return;
}
void HP_clif_pet_emotion(struct pet_data *pd, int param) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pet_emotion_pre ) {
		void (*preHookFunc) (struct pet_data **pd, int *param);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pet_emotion(pd, param);
	}
	if( HPMHooks.count.HP_clif_pet_emotion_post ) {
		void (*postHookFunc) (struct pet_data *pd, int param);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_emotion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pet_emotion_post[hIndex].func;
			postHookFunc(pd, param);
		}
	}
	return;
}
void HP_clif_pet_food(struct map_session_data *sd, int foodid, int fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pet_food_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *foodid, int *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pet_food(sd, foodid, fail);
	}
	if( HPMHooks.count.HP_clif_pet_food_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int foodid, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pet_food_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pet_food_post[hIndex].func;
			postHookFunc(sd, foodid, fail);
		}
	}
	return;
}
int HP_clif_friendslist_toggle_sub(struct map_session_data *sd, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.clif.friendslist_toggle_sub(sd, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_clif_friendslist_toggle_sub_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_clif_friendslist_send(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_friendslist_send_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.friendslist_send(sd);
	}
	if( HPMHooks.count.HP_clif_friendslist_send_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_send_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_friendslist_send_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_friendslist_reqack(struct map_session_data *sd, struct map_session_data *f_sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_friendslist_reqack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **f_sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.friendslist_reqack(sd, f_sd, type);
	}
	if( HPMHooks.count.HP_clif_friendslist_reqack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *f_sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_reqack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_friendslist_reqack_post[hIndex].func;
			postHookFunc(sd, f_sd, type);
		}
	}
	return;
}
void HP_clif_friendslist_toggle(struct map_session_data *sd, int account_id, int char_id, int online) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_friendslist_toggle_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *account_id, int *char_id, int *online);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.friendslist_toggle(sd, account_id, char_id, online);
	}
	if( HPMHooks.count.HP_clif_friendslist_toggle_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int account_id, int char_id, int online);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendslist_toggle_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_friendslist_toggle_post[hIndex].func;
			postHookFunc(sd, account_id, char_id, online);
		}
	}
	return;
}
void HP_clif_friendlist_req(struct map_session_data *sd, int account_id, int char_id, const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_friendlist_req_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *account_id, int *char_id, const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.friendlist_req(sd, account_id, char_id, name);
	}
	if( HPMHooks.count.HP_clif_friendlist_req_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int account_id, int char_id, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_friendlist_req_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_friendlist_req_post[hIndex].func;
			postHookFunc(sd, account_id, char_id, name);
		}
	}
	return;
}
void HP_clif_GM_kickack(struct map_session_data *sd, int result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_GM_kickack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *result);
		*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, &result);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.GM_kickack(sd, result);
	}
	if( HPMHooks.count.HP_clif_GM_kickack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kickack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_GM_kickack_post[hIndex].func;
			postHookFunc(sd, result);
		}
	}
	return;
}
void HP_clif_GM_kick(struct map_session_data *sd, struct map_session_data *tsd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_GM_kick_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.GM_kick(sd, tsd);
	}
	if( HPMHooks.count.HP_clif_GM_kick_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_kick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_GM_kick_post[hIndex].func;
			postHookFunc(sd, tsd);
		}
	}
	return;
}
void HP_clif_manner_message(struct map_session_data *sd, uint32 type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_manner_message_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, uint32 *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.manner_message(sd, type);
	}
	if( HPMHooks.count.HP_clif_manner_message_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint32 type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_manner_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_manner_message_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_GM_silence(struct map_session_data *sd, struct map_session_data *tsd, uint8 type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_GM_silence_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **tsd, uint8 *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.GM_silence(sd, tsd, type);
	}
	if( HPMHooks.count.HP_clif_GM_silence_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *tsd, uint8 type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_GM_silence_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_GM_silence_post[hIndex].func;
			postHookFunc(sd, tsd, type);
		}
	}
	return;
}
void HP_clif_account_name(struct map_session_data *sd, int account_id, const char *accname) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_account_name_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *account_id, const char **accname);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.account_name(sd, account_id, accname);
	}
	if( HPMHooks.count.HP_clif_account_name_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int account_id, const char *accname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_account_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_account_name_post[hIndex].func;
			postHookFunc(sd, account_id, accname);
		}
	}
	return;
}
void HP_clif_check(int fd, struct map_session_data *pl_sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_check_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **pl_sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.check(fd, pl_sd);
	}
	if( HPMHooks.count.HP_clif_check_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *pl_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_check_post[hIndex].func;
			postHookFunc(fd, pl_sd);
		}
	}
	return;
}
void HP_clif_hominfo(struct map_session_data *sd, struct homun_data *hd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_hominfo_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct homun_data **hd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.hominfo(sd, hd, flag);
	}
	if( HPMHooks.count.HP_clif_hominfo_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct homun_data *hd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hominfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_hominfo_post[hIndex].func;
			postHookFunc(sd, hd, flag);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.homskillinfoblock(sd);
	}
	if( HPMHooks.count.HP_clif_homskillinfoblock_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillinfoblock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_homskillinfoblock_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.homskillup(sd, skill_id);
	}
	if( HPMHooks.count.HP_clif_homskillup_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_homskillup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_homskillup_post[hIndex].func;
			postHookFunc(sd, skill_id);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.hom_food(sd, foodid, fail);
	}
	if( HPMHooks.count.HP_clif_hom_food_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int foodid, int fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_hom_food_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_hom_food_post[hIndex].func;
			postHookFunc(sd, foodid, fail);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.send_homdata(sd, state, param);
	}
	if( HPMHooks.count.HP_clif_send_homdata_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int state, int param);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_send_homdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_send_homdata_post[hIndex].func;
			postHookFunc(sd, state, param);
		}
	}
	return;
}
void HP_clif_quest_send_list(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_quest_send_list_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.quest_send_list(sd);
	}
	if( HPMHooks.count.HP_clif_quest_send_list_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_send_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_quest_send_list_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_quest_send_mission(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_quest_send_mission_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.quest_send_mission(sd);
	}
	if( HPMHooks.count.HP_clif_quest_send_mission_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_send_mission_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_quest_send_mission_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_quest_add(struct map_session_data *sd, struct quest *qd) {
	int 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.quest_add(sd, qd);
	}
	if( HPMHooks.count.HP_clif_quest_add_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct quest *qd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_quest_add_post[hIndex].func;
			postHookFunc(sd, qd);
		}
	}
	return;
}
void HP_clif_quest_delete(struct map_session_data *sd, int quest_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_quest_delete_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *quest_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.quest_delete(sd, quest_id);
	}
	if( HPMHooks.count.HP_clif_quest_delete_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int quest_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_quest_delete_post[hIndex].func;
			postHookFunc(sd, quest_id);
		}
	}
	return;
}
void HP_clif_quest_update_status(struct map_session_data *sd, int quest_id, bool active) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_quest_update_status_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *quest_id, bool *active);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.quest_update_status(sd, quest_id, active);
	}
	if( HPMHooks.count.HP_clif_quest_update_status_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int quest_id, bool active);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_status_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_quest_update_status_post[hIndex].func;
			postHookFunc(sd, quest_id, active);
		}
	}
	return;
}
void HP_clif_quest_update_objective(struct map_session_data *sd, struct quest *qd) {
	int 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.quest_update_objective(sd, qd);
	}
	if( HPMHooks.count.HP_clif_quest_update_objective_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct quest *qd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_update_objective_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_quest_update_objective_post[hIndex].func;
			postHookFunc(sd, qd);
		}
	}
	return;
}
void HP_clif_quest_show_event(struct map_session_data *sd, struct block_list *bl, short state, short color) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_quest_show_event_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct block_list **bl, short *state, short *color);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.quest_show_event(sd, bl, state, color);
	}
	if( HPMHooks.count.HP_clif_quest_show_event_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct block_list *bl, short state, short color);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_quest_show_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_quest_show_event_post[hIndex].func;
			postHookFunc(sd, bl, state, color);
		}
	}
	return;
}
void HP_clif_mail_window(int fd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_window_pre ) {
		void (*preHookFunc) (int *fd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_window(fd, flag);
	}
	if( HPMHooks.count.HP_clif_mail_window_post ) {
		void (*postHookFunc) (int fd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_window_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_window_post[hIndex].func;
			postHookFunc(fd, flag);
		}
	}
	return;
}
void HP_clif_mail_read(struct map_session_data *sd, int mail_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_read_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *mail_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_read(sd, mail_id);
	}
	if( HPMHooks.count.HP_clif_mail_read_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int mail_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_read_post[hIndex].func;
			postHookFunc(sd, mail_id);
		}
	}
	return;
}
void HP_clif_mail_delete(int fd, int mail_id, short fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_delete_pre ) {
		void (*preHookFunc) (int *fd, int *mail_id, short *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_delete(fd, mail_id, fail);
	}
	if( HPMHooks.count.HP_clif_mail_delete_post ) {
		void (*postHookFunc) (int fd, int mail_id, short fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_delete_post[hIndex].func;
			postHookFunc(fd, mail_id, fail);
		}
	}
	return;
}
void HP_clif_mail_return(int fd, int mail_id, short fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_return_pre ) {
		void (*preHookFunc) (int *fd, int *mail_id, short *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_return(fd, mail_id, fail);
	}
	if( HPMHooks.count.HP_clif_mail_return_post ) {
		void (*postHookFunc) (int fd, int mail_id, short fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_return_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_return_post[hIndex].func;
			postHookFunc(fd, mail_id, fail);
		}
	}
	return;
}
void HP_clif_mail_send(int fd, bool fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_send_pre ) {
		void (*preHookFunc) (int *fd, bool *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_send(fd, fail);
	}
	if( HPMHooks.count.HP_clif_mail_send_post ) {
		void (*postHookFunc) (int fd, bool fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_send_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_send_post[hIndex].func;
			postHookFunc(fd, fail);
		}
	}
	return;
}
void HP_clif_mail_new(int fd, int mail_id, const char *sender, const char *title) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_new_pre ) {
		void (*preHookFunc) (int *fd, int *mail_id, const char **sender, const char **title);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_new(fd, mail_id, sender, title);
	}
	if( HPMHooks.count.HP_clif_mail_new_post ) {
		void (*postHookFunc) (int fd, int mail_id, const char *sender, const char *title);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_new_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_new_post[hIndex].func;
			postHookFunc(fd, mail_id, sender, title);
		}
	}
	return;
}
void HP_clif_mail_refreshinbox(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_refreshinbox_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_refreshinbox(sd);
	}
	if( HPMHooks.count.HP_clif_mail_refreshinbox_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_refreshinbox_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_refreshinbox_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_mail_getattachment(int fd, uint8 flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_getattachment_pre ) {
		void (*preHookFunc) (int *fd, uint8 *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_getattachment(fd, flag);
	}
	if( HPMHooks.count.HP_clif_mail_getattachment_post ) {
		void (*postHookFunc) (int fd, uint8 flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_getattachment_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_getattachment_post[hIndex].func;
			postHookFunc(fd, flag);
		}
	}
	return;
}
void HP_clif_mail_setattachment(int fd, int index, uint8 flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mail_setattachment_pre ) {
		void (*preHookFunc) (int *fd, int *index, uint8 *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mail_setattachment(fd, index, flag);
	}
	if( HPMHooks.count.HP_clif_mail_setattachment_post ) {
		void (*postHookFunc) (int fd, int index, uint8 flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mail_setattachment_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mail_setattachment_post[hIndex].func;
			postHookFunc(fd, index, flag);
		}
	}
	return;
}
void HP_clif_auction_openwindow(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_auction_openwindow_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.auction_openwindow(sd);
	}
	if( HPMHooks.count.HP_clif_auction_openwindow_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_openwindow_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_auction_openwindow_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_auction_results(struct map_session_data *sd, short count, short pages, const uint8 *buf) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_auction_results_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *count, short *pages, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.auction_results(sd, count, pages, buf);
	}
	if( HPMHooks.count.HP_clif_auction_results_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short count, short pages, const uint8 *buf);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_results_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_auction_results_post[hIndex].func;
			postHookFunc(sd, count, pages, buf);
		}
	}
	return;
}
void HP_clif_auction_message(int fd, unsigned char flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_auction_message_pre ) {
		void (*preHookFunc) (int *fd, unsigned char *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.auction_message(fd, flag);
	}
	if( HPMHooks.count.HP_clif_auction_message_post ) {
		void (*postHookFunc) (int fd, unsigned char flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_auction_message_post[hIndex].func;
			postHookFunc(fd, flag);
		}
	}
	return;
}
void HP_clif_auction_close(int fd, unsigned char flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_auction_close_pre ) {
		void (*preHookFunc) (int *fd, unsigned char *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.auction_close(fd, flag);
	}
	if( HPMHooks.count.HP_clif_auction_close_post ) {
		void (*postHookFunc) (int fd, unsigned char flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_auction_close_post[hIndex].func;
			postHookFunc(fd, flag);
		}
	}
	return;
}
void HP_clif_auction_setitem(int fd, int index, bool fail) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_auction_setitem_pre ) {
		void (*preHookFunc) (int *fd, int *index, bool *fail);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.auction_setitem(fd, index, fail);
	}
	if( HPMHooks.count.HP_clif_auction_setitem_post ) {
		void (*postHookFunc) (int fd, int index, bool fail);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_auction_setitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_auction_setitem_post[hIndex].func;
			postHookFunc(fd, index, fail);
		}
	}
	return;
}
void HP_clif_mercenary_info(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mercenary_info_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mercenary_info(sd);
	}
	if( HPMHooks.count.HP_clif_mercenary_info_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mercenary_info_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_mercenary_skillblock(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mercenary_skillblock_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mercenary_skillblock(sd);
	}
	if( HPMHooks.count.HP_clif_mercenary_skillblock_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_skillblock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mercenary_skillblock_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_mercenary_message(struct map_session_data *sd, int message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mercenary_message_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *message);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mercenary_message(sd, message);
	}
	if( HPMHooks.count.HP_clif_mercenary_message_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mercenary_message_post[hIndex].func;
			postHookFunc(sd, message);
		}
	}
	return;
}
void HP_clif_mercenary_updatestatus(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_mercenary_updatestatus_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.mercenary_updatestatus(sd, type);
	}
	if( HPMHooks.count.HP_clif_mercenary_updatestatus_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_mercenary_updatestatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_mercenary_updatestatus_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_rental_time(int fd, int nameid, int seconds) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_rental_time_pre ) {
		void (*preHookFunc) (int *fd, int *nameid, int *seconds);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.rental_time(fd, nameid, seconds);
	}
	if( HPMHooks.count.HP_clif_rental_time_post ) {
		void (*postHookFunc) (int fd, int nameid, int seconds);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_rental_time_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_rental_time_post[hIndex].func;
			postHookFunc(fd, nameid, seconds);
		}
	}
	return;
}
void HP_clif_rental_expired(int fd, int index, int nameid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_rental_expired_pre ) {
		void (*preHookFunc) (int *fd, int *index, int *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.rental_expired(fd, index, nameid);
	}
	if( HPMHooks.count.HP_clif_rental_expired_post ) {
		void (*postHookFunc) (int fd, int index, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_rental_expired_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_rental_expired_post[hIndex].func;
			postHookFunc(fd, index, nameid);
		}
	}
	return;
}
void HP_clif_PartyBookingRegisterAck(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingRegisterAck_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingRegisterAck(sd, flag);
	}
	if( HPMHooks.count.HP_clif_PartyBookingRegisterAck_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRegisterAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingRegisterAck_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_PartyBookingDeleteAck(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingDeleteAck_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingDeleteAck(sd, flag);
	}
	if( HPMHooks.count.HP_clif_PartyBookingDeleteAck_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteAck_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_PartyBookingSearchAck(int fd, struct party_booking_ad_info **results, int count, bool more_result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingSearchAck_pre ) {
		void (*preHookFunc) (int *fd, struct party_booking_ad_info ***results, int *count, bool *more_result);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingSearchAck(fd, results, count, more_result);
	}
	if( HPMHooks.count.HP_clif_PartyBookingSearchAck_post ) {
		void (*postHookFunc) (int fd, struct party_booking_ad_info **results, int count, bool more_result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSearchAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingSearchAck_post[hIndex].func;
			postHookFunc(fd, results, count, more_result);
		}
	}
	return;
}
void HP_clif_PartyBookingUpdateNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingUpdateNotify_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingUpdateNotify(sd, pb_ad);
	}
	if( HPMHooks.count.HP_clif_PartyBookingUpdateNotify_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingUpdateNotify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingUpdateNotify_post[hIndex].func;
			postHookFunc(sd, pb_ad);
		}
	}
	return;
}
void HP_clif_PartyBookingDeleteNotify(struct map_session_data *sd, int index) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingDeleteNotify_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *index);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingDeleteNotify(sd, index);
	}
	if( HPMHooks.count.HP_clif_PartyBookingDeleteNotify_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingDeleteNotify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingDeleteNotify_post[hIndex].func;
			postHookFunc(sd, index);
		}
	}
	return;
}
void HP_clif_PartyBookingInsertNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingInsertNotify_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct party_booking_ad_info **pb_ad);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingInsertNotify(sd, pb_ad);
	}
	if( HPMHooks.count.HP_clif_PartyBookingInsertNotify_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingInsertNotify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingInsertNotify_post[hIndex].func;
			postHookFunc(sd, pb_ad);
		}
	}
	return;
}
void HP_clif_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyRecruitRegisterAck(sd, flag);
	}
	if( HPMHooks.count.HP_clif_PartyRecruitRegisterAck_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitRegisterAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyRecruitRegisterAck_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyRecruitDeleteAck(sd, flag);
	}
	if( HPMHooks.count.HP_clif_PartyRecruitDeleteAck_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitDeleteAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyRecruitDeleteAck_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_clif_PartyRecruitSearchAck(int fd, struct party_booking_ad_info **results, int count, bool more_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyRecruitSearchAck(fd, results, count, more_result);
	}
	if( HPMHooks.count.HP_clif_PartyRecruitSearchAck_post ) {
		void (*postHookFunc) (int fd, struct party_booking_ad_info **results, int count, bool more_result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitSearchAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyRecruitSearchAck_post[hIndex].func;
			postHookFunc(fd, results, count, more_result);
		}
	}
	return;
}
void HP_clif_PartyRecruitUpdateNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyRecruitUpdateNotify(sd, pb_ad);
	}
	if( HPMHooks.count.HP_clif_PartyRecruitUpdateNotify_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitUpdateNotify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyRecruitUpdateNotify_post[hIndex].func;
			postHookFunc(sd, pb_ad);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyRecruitDeleteNotify(sd, index);
	}
	if( HPMHooks.count.HP_clif_PartyRecruitDeleteNotify_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitDeleteNotify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyRecruitDeleteNotify_post[hIndex].func;
			postHookFunc(sd, index);
		}
	}
	return;
}
void HP_clif_PartyRecruitInsertNotify(struct map_session_data *sd, struct party_booking_ad_info *pb_ad) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyRecruitInsertNotify(sd, pb_ad);
	}
	if( HPMHooks.count.HP_clif_PartyRecruitInsertNotify_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct party_booking_ad_info *pb_ad);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyRecruitInsertNotify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyRecruitInsertNotify_post[hIndex].func;
			postHookFunc(sd, pb_ad);
		}
	}
	return;
}
void HP_clif_PartyBookingVolunteerInfo(int index, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_pre ) {
		void (*preHookFunc) (int *index, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingVolunteerInfo(index, sd);
	}
	if( HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_post ) {
		void (*postHookFunc) (int index, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingVolunteerInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingVolunteerInfo_post[hIndex].func;
			postHookFunc(index, sd);
		}
	}
	return;
}
void HP_clif_PartyBookingRefuseVolunteer(unsigned int aid, struct map_session_data *sd) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingRefuseVolunteer(aid, sd);
	}
	if( HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_post ) {
		void (*postHookFunc) (unsigned int aid, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingRefuseVolunteer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingRefuseVolunteer_post[hIndex].func;
			postHookFunc(aid, sd);
		}
	}
	return;
}
void HP_clif_PartyBookingCancelVolunteer(int index, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_pre ) {
		void (*preHookFunc) (int *index, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingCancelVolunteer(index, sd);
	}
	if( HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_post ) {
		void (*postHookFunc) (int index, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingCancelVolunteer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingCancelVolunteer_post[hIndex].func;
			postHookFunc(index, sd);
		}
	}
	return;
}
void HP_clif_PartyBookingAddFilteringList(int index, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingAddFilteringList_pre ) {
		void (*preHookFunc) (int *index, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingAddFilteringList(index, sd);
	}
	if( HPMHooks.count.HP_clif_PartyBookingAddFilteringList_post ) {
		void (*postHookFunc) (int index, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingAddFilteringList_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingAddFilteringList_post[hIndex].func;
			postHookFunc(index, sd);
		}
	}
	return;
}
void HP_clif_PartyBookingSubFilteringList(int gid, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_PartyBookingSubFilteringList_pre ) {
		void (*preHookFunc) (int *gid, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.PartyBookingSubFilteringList(gid, sd);
	}
	if( HPMHooks.count.HP_clif_PartyBookingSubFilteringList_post ) {
		void (*postHookFunc) (int gid, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_PartyBookingSubFilteringList_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_PartyBookingSubFilteringList_post[hIndex].func;
			postHookFunc(gid, sd);
		}
	}
	return;
}
void HP_clif_buyingstore_open(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_open_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_open(sd);
	}
	if( HPMHooks.count.HP_clif_buyingstore_open_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_open_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_buyingstore_open_failed(struct map_session_data *sd, unsigned short result, unsigned int weight) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_open_failed_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short *result, unsigned int *weight);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_open_failed(sd, result, weight);
	}
	if( HPMHooks.count.HP_clif_buyingstore_open_failed_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short result, unsigned int weight);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_open_failed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_open_failed_post[hIndex].func;
			postHookFunc(sd, result, weight);
		}
	}
	return;
}
void HP_clif_buyingstore_myitemlist(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_myitemlist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_myitemlist(sd);
	}
	if( HPMHooks.count.HP_clif_buyingstore_myitemlist_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_myitemlist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_myitemlist_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_buyingstore_entry(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_entry_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_entry(sd);
	}
	if( HPMHooks.count.HP_clif_buyingstore_entry_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_buyingstore_entry_single(struct map_session_data *sd, struct map_session_data *pl_sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_entry_single_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **pl_sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_entry_single(sd, pl_sd);
	}
	if( HPMHooks.count.HP_clif_buyingstore_entry_single_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_entry_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_entry_single_post[hIndex].func;
			postHookFunc(sd, pl_sd);
		}
	}
	return;
}
void HP_clif_buyingstore_disappear_entry(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_disappear_entry(sd);
	}
	if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_disappear_entry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_disappear_entry_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_buyingstore_disappear_entry_single(struct map_session_data *sd, struct map_session_data *pl_sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **pl_sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_disappear_entry_single(sd, pl_sd);
	}
	if( HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_disappear_entry_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_disappear_entry_single_post[hIndex].func;
			postHookFunc(sd, pl_sd);
		}
	}
	return;
}
void HP_clif_buyingstore_itemlist(struct map_session_data *sd, struct map_session_data *pl_sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_itemlist_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **pl_sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_itemlist(sd, pl_sd);
	}
	if( HPMHooks.count.HP_clif_buyingstore_itemlist_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *pl_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_itemlist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_itemlist_post[hIndex].func;
			postHookFunc(sd, pl_sd);
		}
	}
	return;
}
void HP_clif_buyingstore_trade_failed_buyer(struct map_session_data *sd, short result) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *result);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_trade_failed_buyer(sd, result);
	}
	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short result);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_buyer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_buyer_post[hIndex].func;
			postHookFunc(sd, result);
		}
	}
	return;
}
void HP_clif_buyingstore_update_item(struct map_session_data *sd, unsigned short nameid, unsigned short amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_update_item_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned short *nameid, unsigned short *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_update_item(sd, nameid, amount);
	}
	if( HPMHooks.count.HP_clif_buyingstore_update_item_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short nameid, unsigned short amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_update_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_update_item_post[hIndex].func;
			postHookFunc(sd, nameid, amount);
		}
	}
	return;
}
void HP_clif_buyingstore_delete_item(struct map_session_data *sd, short index, unsigned short amount, int price) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_delete_item_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *index, unsigned short *amount, int *price);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_delete_item(sd, index, amount, price);
	}
	if( HPMHooks.count.HP_clif_buyingstore_delete_item_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short index, unsigned short amount, int price);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_delete_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_delete_item_post[hIndex].func;
			postHookFunc(sd, index, amount, price);
		}
	}
	return;
}
void HP_clif_buyingstore_trade_failed_seller(struct map_session_data *sd, short result, unsigned short nameid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *result, unsigned short *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.buyingstore_trade_failed_seller(sd, result, nameid);
	}
	if( HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short result, unsigned short nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_buyingstore_trade_failed_seller_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_buyingstore_trade_failed_seller_post[hIndex].func;
			postHookFunc(sd, result, nameid);
		}
	}
	return;
}
void HP_clif_search_store_info_ack(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_search_store_info_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.search_store_info_ack(sd);
	}
	if( HPMHooks.count.HP_clif_search_store_info_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_search_store_info_ack_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_search_store_info_failed(struct map_session_data *sd, unsigned char reason) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_search_store_info_failed_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *reason);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.search_store_info_failed(sd, reason);
	}
	if( HPMHooks.count.HP_clif_search_store_info_failed_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char reason);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_failed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_search_store_info_failed_post[hIndex].func;
			postHookFunc(sd, reason);
		}
	}
	return;
}
void HP_clif_open_search_store_info(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_open_search_store_info_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.open_search_store_info(sd);
	}
	if( HPMHooks.count.HP_clif_open_search_store_info_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_open_search_store_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_open_search_store_info_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_search_store_info_click_ack(struct map_session_data *sd, short x, short y) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_search_store_info_click_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *x, short *y);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.search_store_info_click_ack(sd, x, y);
	}
	if( HPMHooks.count.HP_clif_search_store_info_click_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short x, short y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_search_store_info_click_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_search_store_info_click_ack_post[hIndex].func;
			postHookFunc(sd, x, y);
		}
	}
	return;
}
void HP_clif_elemental_info(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_elemental_info_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.elemental_info(sd);
	}
	if( HPMHooks.count.HP_clif_elemental_info_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_elemental_info_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_elemental_updatestatus(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_elemental_updatestatus_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.elemental_updatestatus(sd, type);
	}
	if( HPMHooks.count.HP_clif_elemental_updatestatus_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_elemental_updatestatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_elemental_updatestatus_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_bgqueue_ack(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK response, unsigned char arena_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bgqueue_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum BATTLEGROUNDS_QUEUE_ACK *response, unsigned char *arena_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bgqueue_ack(sd, response, arena_id);
	}
	if( HPMHooks.count.HP_clif_bgqueue_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_ACK response, unsigned char arena_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bgqueue_ack_post[hIndex].func;
			postHookFunc(sd, response, arena_id);
		}
	}
	return;
}
void HP_clif_bgqueue_notice_delete(struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED response, const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bgqueue_notice_delete_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED *response, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bgqueue_notice_delete(sd, response, name);
	}
	if( HPMHooks.count.HP_clif_bgqueue_notice_delete_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum BATTLEGROUNDS_QUEUE_NOTICE_DELETED response, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_notice_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bgqueue_notice_delete_post[hIndex].func;
			postHookFunc(sd, response, name);
		}
	}
	return;
}
void HP_clif_bgqueue_update_info(struct map_session_data *sd, unsigned char arena_id, int position) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bgqueue_update_info_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *arena_id, int *position);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bgqueue_update_info(sd, arena_id, position);
	}
	if( HPMHooks.count.HP_clif_bgqueue_update_info_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char arena_id, int position);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_update_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bgqueue_update_info_post[hIndex].func;
			postHookFunc(sd, arena_id, position);
		}
	}
	return;
}
void HP_clif_bgqueue_joined(struct map_session_data *sd, int pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bgqueue_joined_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *pos);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bgqueue_joined(sd, pos);
	}
	if( HPMHooks.count.HP_clif_bgqueue_joined_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_joined_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bgqueue_joined_post[hIndex].func;
			postHookFunc(sd, pos);
		}
	}
	return;
}
void HP_clif_bgqueue_pcleft(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bgqueue_pcleft_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bgqueue_pcleft(sd);
	}
	if( HPMHooks.count.HP_clif_bgqueue_pcleft_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_pcleft_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bgqueue_pcleft_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_bgqueue_battlebegins(struct map_session_data *sd, unsigned char arena_id, enum send_target target) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bgqueue_battlebegins_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *arena_id, enum send_target *target);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bgqueue_battlebegins(sd, arena_id, target);
	}
	if( HPMHooks.count.HP_clif_bgqueue_battlebegins_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char arena_id, enum send_target target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bgqueue_battlebegins_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bgqueue_battlebegins_post[hIndex].func;
			postHookFunc(sd, arena_id, target);
		}
	}
	return;
}
void HP_clif_adopt_reply(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_adopt_reply_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.adopt_reply(sd, type);
	}
	if( HPMHooks.count.HP_clif_adopt_reply_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_reply_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_adopt_reply_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_clif_adopt_request(struct map_session_data *sd, struct map_session_data *src, int p_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_adopt_request_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **src, int *p_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.adopt_request(sd, src, p_id);
	}
	if( HPMHooks.count.HP_clif_adopt_request_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *src, int p_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_adopt_request_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_adopt_request_post[hIndex].func;
			postHookFunc(sd, src, p_id);
		}
	}
	return;
}
void HP_clif_readbook(int fd, int book_id, int page) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_readbook_pre ) {
		void (*preHookFunc) (int *fd, int *book_id, int *page);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.readbook(fd, book_id, page);
	}
	if( HPMHooks.count.HP_clif_readbook_post ) {
		void (*postHookFunc) (int fd, int book_id, int page);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_readbook_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_readbook_post[hIndex].func;
			postHookFunc(fd, book_id, page);
		}
	}
	return;
}
void HP_clif_notify_time(struct map_session_data *sd, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.notify_time(sd, time);
	}
	if( HPMHooks.count.HP_clif_notify_time_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int64 time);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_time_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_notify_time_post[hIndex].func;
			postHookFunc(sd, time);
		}
	}
	return;
}
void HP_clif_user_count(struct map_session_data *sd, int count) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_user_count_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *count);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.user_count(sd, count);
	}
	if( HPMHooks.count.HP_clif_user_count_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_user_count_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_user_count_post[hIndex].func;
			postHookFunc(sd, count);
		}
	}
	return;
}
void HP_clif_noask_sub(struct map_session_data *src, struct map_session_data *target, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_noask_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **src, struct map_session_data **target, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.noask_sub(src, target, type);
	}
	if( HPMHooks.count.HP_clif_noask_sub_post ) {
		void (*postHookFunc) (struct map_session_data *src, struct map_session_data *target, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_noask_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_noask_sub_post[hIndex].func;
			postHookFunc(src, target, type);
		}
	}
	return;
}
void HP_clif_bc_ready(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_bc_ready_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bc_ready();
	}
	if( HPMHooks.count.HP_clif_bc_ready_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bc_ready_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bc_ready_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_clif_channel_msg(struct channel_data *chan, struct map_session_data *sd, char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_channel_msg_pre ) {
		void (*preHookFunc) (struct channel_data **chan, struct map_session_data **sd, char **msg);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_channel_msg_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_channel_msg_pre[hIndex].func;
			preHookFunc(&chan, &sd, &msg);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.channel_msg(chan, sd, msg);
	}
	if( HPMHooks.count.HP_clif_channel_msg_post ) {
		void (*postHookFunc) (struct channel_data *chan, struct map_session_data *sd, char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_channel_msg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_channel_msg_post[hIndex].func;
			postHookFunc(chan, sd, msg);
		}
	}
	return;
}
void HP_clif_channel_msg2(struct channel_data *chan, char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_channel_msg2_pre ) {
		void (*preHookFunc) (struct channel_data **chan, char **msg);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_channel_msg2_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_channel_msg2_pre[hIndex].func;
			preHookFunc(&chan, &msg);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.channel_msg2(chan, msg);
	}
	if( HPMHooks.count.HP_clif_channel_msg2_post ) {
		void (*postHookFunc) (struct channel_data *chan, char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_channel_msg2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_channel_msg2_post[hIndex].func;
			postHookFunc(chan, msg);
		}
	}
	return;
}
int HP_clif_undisguise_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.undisguise_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_clif_undisguise_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_undisguise_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_undisguise_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_clif_bank_deposit(struct map_session_data *sd, enum e_BANKING_DEPOSIT_ACK reason) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bank_deposit(sd, reason);
	}
	if( HPMHooks.count.HP_clif_bank_deposit_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum e_BANKING_DEPOSIT_ACK reason);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bank_deposit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bank_deposit_post[hIndex].func;
			postHookFunc(sd, reason);
		}
	}
	return;
}
void HP_clif_bank_withdraw(struct map_session_data *sd, enum e_BANKING_WITHDRAW_ACK reason) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.bank_withdraw(sd, reason);
	}
	if( HPMHooks.count.HP_clif_bank_withdraw_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum e_BANKING_WITHDRAW_ACK reason);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bank_withdraw_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bank_withdraw_post[hIndex].func;
			postHookFunc(sd, reason);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.show_modifiers(sd);
	}
	if( HPMHooks.count.HP_clif_show_modifiers_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_show_modifiers_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_show_modifiers_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.notify_bounditem(sd, index);
	}
	if( HPMHooks.count.HP_clif_notify_bounditem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned short index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_notify_bounditem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_notify_bounditem_post[hIndex].func;
			postHookFunc(sd, index);
		}
	}
	return;
}
int HP_clif_delay_damage(int64 tick, struct block_list *src, struct block_list *dst, int sdelay, int ddelay, int64 in_damage, short div, unsigned char type) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.delay_damage(tick, src, dst, sdelay, ddelay, in_damage, div, type);
	}
	if( HPMHooks.count.HP_clif_delay_damage_post ) {
		int (*postHookFunc) (int retVal___, int64 tick, struct block_list *src, struct block_list *dst, int sdelay, int ddelay, int64 in_damage, short div, unsigned char type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delay_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_delay_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tick, src, dst, sdelay, ddelay, in_damage, div, type);
		}
	}
	return retVal___;
}
int HP_clif_delay_damage_sub(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.delay_damage_sub(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_clif_delay_damage_sub_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_delay_damage_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_delay_damage_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.npc_market_open(sd, nd);
	}
	if( HPMHooks.count.HP_clif_npc_market_open_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_market_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_npc_market_open_post[hIndex].func;
			postHookFunc(sd, nd);
		}
	}
	return;
}
void HP_clif_npc_market_purchase_ack(struct map_session_data *sd, const struct itemlist *item_list, unsigned char response) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_npc_market_purchase_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const struct itemlist **item_list, 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, &item_list, &response);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.npc_market_purchase_ack(sd, item_list, response);
	}
	if( HPMHooks.count.HP_clif_npc_market_purchase_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const struct itemlist *item_list, unsigned char response);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_npc_market_purchase_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_npc_market_purchase_ack_post[hIndex].func;
			postHookFunc(sd, item_list, response);
		}
	}
	return;
}
bool HP_clif_parse_roulette_db(void) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_clif_parse_roulette_db_pre ) {
		bool (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_roulette_db_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_parse_roulette_db_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.parse_roulette_db();
	}
	if( HPMHooks.count.HP_clif_parse_roulette_db_post ) {
		bool (*postHookFunc) (bool retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_parse_roulette_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_parse_roulette_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_clif_roulette_generate_ack(struct map_session_data *sd, unsigned char result, short stage, short prizeIdx, short bonusItemID) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_roulette_generate_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *result, short *stage, short *prizeIdx, short *bonusItemID);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_roulette_generate_ack_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_roulette_generate_ack_pre[hIndex].func;
			preHookFunc(&sd, &result, &stage, &prizeIdx, &bonusItemID);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.roulette_generate_ack(sd, result, stage, prizeIdx, bonusItemID);
	}
	if( HPMHooks.count.HP_clif_roulette_generate_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char result, short stage, short prizeIdx, short bonusItemID);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_roulette_generate_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_roulette_generate_ack_post[hIndex].func;
			postHookFunc(sd, result, stage, prizeIdx, bonusItemID);
		}
	}
	return;
}
void HP_clif_openmergeitem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_openmergeitem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openmergeitem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_openmergeitem_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.openmergeitem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_openmergeitem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_openmergeitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_openmergeitem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_cancelmergeitem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_cancelmergeitem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cancelmergeitem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_cancelmergeitem_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.cancelmergeitem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_cancelmergeitem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_cancelmergeitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_cancelmergeitem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
int HP_clif_comparemergeitem(const void *a, const void *b) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_clif_comparemergeitem_pre ) {
		int (*preHookFunc) (const void **a, const void **b);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_comparemergeitem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_comparemergeitem_pre[hIndex].func;
			retVal___ = preHookFunc(&a, &b);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.comparemergeitem(a, b);
	}
	if( HPMHooks.count.HP_clif_comparemergeitem_post ) {
		int (*postHookFunc) (int retVal___, const void *a, const void *b);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_comparemergeitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_comparemergeitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, a, b);
		}
	}
	return retVal___;
}
void HP_clif_ackmergeitems(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_ackmergeitems_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ackmergeitems_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_ackmergeitems_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.ackmergeitems(fd, sd);
	}
	if( HPMHooks.count.HP_clif_ackmergeitems_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_ackmergeitems_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_ackmergeitems_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
bool HP_clif_isdisguised(struct block_list *bl) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_clif_isdisguised_pre ) {
		bool (*preHookFunc) (struct block_list **bl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_isdisguised_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_isdisguised_pre[hIndex].func;
			retVal___ = preHookFunc(&bl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.isdisguised(bl);
	}
	if( HPMHooks.count.HP_clif_isdisguised_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_isdisguised_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_isdisguised_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
unsigned char HP_clif_bl_type(struct block_list *bl) {
	int hIndex = 0;
	unsigned char retVal___ = 0;
	if( HPMHooks.count.HP_clif_bl_type_pre ) {
		unsigned char (*preHookFunc) (struct block_list **bl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bl_type_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_bl_type_pre[hIndex].func;
			retVal___ = preHookFunc(&bl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.bl_type(bl);
	}
	if( HPMHooks.count.HP_clif_bl_type_post ) {
		unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_bl_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_bl_type_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pWantToConnection(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pWantToConnection_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWantToConnection_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pWantToConnection_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pLoadEndAck(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pLoadEndAck_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pLoadEndAck(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pLoadEndAck_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLoadEndAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pLoadEndAck_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pTickSend(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pTickSend_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTickSend(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTickSend_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTickSend_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTickSend_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pHotkey(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pHotkey_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pHotkey(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pHotkey_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkey_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pHotkey_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pProgressbar(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pProgressbar_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pProgressbar(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pProgressbar_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProgressbar_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pProgressbar_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pWalkToXY(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pWalkToXY_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pWalkToXY(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pWalkToXY_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWalkToXY_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pWalkToXY_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pQuitGame(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pQuitGame_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pQuitGame(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pQuitGame_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pQuitGame_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pQuitGame_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGetCharNameRequest(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGetCharNameRequest_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGetCharNameRequest(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGetCharNameRequest_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetCharNameRequest_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGetCharNameRequest_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGlobalMessage(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGlobalMessage_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGlobalMessage(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGlobalMessage_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGlobalMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGlobalMessage_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMapMove(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMapMove_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMapMove(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMapMove_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMapMove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMapMove_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pChangeDir(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pChangeDir_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pChangeDir(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pChangeDir_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeDir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pChangeDir_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pEmotion(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pEmotion_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pEmotion(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pEmotion_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEmotion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pEmotion_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pHowManyConnections(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pHowManyConnections_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pHowManyConnections(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pHowManyConnections_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHowManyConnections_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pHowManyConnections_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pActionRequest(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pActionRequest_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pActionRequest(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pActionRequest_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pActionRequest_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pActionRequest_sub(struct map_session_data *sd, int action_type, int target_id, int64 tick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pActionRequest_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *action_type, int *target_id, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pActionRequest_sub(sd, action_type, target_id, tick);
	}
	if( HPMHooks.count.HP_clif_pActionRequest_sub_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int action_type, int target_id, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pActionRequest_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pActionRequest_sub_post[hIndex].func;
			postHookFunc(sd, action_type, target_id, tick);
		}
	}
	return;
}
void HP_clif_pRestart(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRestart_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRestart(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRestart_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRestart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRestart_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pWisMessage(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pWisMessage_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pWisMessage(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pWisMessage_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWisMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pWisMessage_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pBroadcast(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pBroadcast_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBroadcast(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBroadcast_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBroadcast_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBroadcast_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pTakeItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pTakeItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTakeItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTakeItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTakeItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTakeItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pDropItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pDropItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pDropItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pDropItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDropItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pDropItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pUseItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pUseItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pEquipItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pEquipItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pEquipItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pEquipItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pEquipItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pUnequipItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUnequipItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUnequipItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pUnequipItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUnequipItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUnequipItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcClicked(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcClicked_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcClicked(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcClicked_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcClicked_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcClicked_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcBuySellSelected(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcBuySellSelected_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcBuySellSelected(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcBuySellSelected_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuySellSelected_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcBuySellSelected_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcBuyListSend(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcBuyListSend_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcBuyListSend(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcBuyListSend_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcBuyListSend_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcBuyListSend_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcSellListSend(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcSellListSend_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcSellListSend(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcSellListSend_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSellListSend_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcSellListSend_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCreateChatRoom(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCreateChatRoom_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCreateChatRoom(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCreateChatRoom_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateChatRoom_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCreateChatRoom_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pChatAddMember(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pChatAddMember_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pChatAddMember(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pChatAddMember_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatAddMember_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pChatAddMember_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pChatRoomStatusChange(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pChatRoomStatusChange_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pChatRoomStatusChange(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pChatRoomStatusChange_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatRoomStatusChange_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pChatRoomStatusChange_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pChangeChatOwner(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pChangeChatOwner_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pChangeChatOwner(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pChangeChatOwner_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeChatOwner_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pChangeChatOwner_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pKickFromChat(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pKickFromChat_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pKickFromChat(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pKickFromChat_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pKickFromChat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pKickFromChat_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pChatLeave(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pChatLeave_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pChatLeave(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pChatLeave_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChatLeave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pChatLeave_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pTradeRequest(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pTradeRequest_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTradeRequest(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTradeRequest_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeRequest_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTradeRequest_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTradeAck(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTradeAck_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTradeAck_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pTradeAddItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pTradeAddItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTradeAddItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTradeAddItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeAddItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTradeAddItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pTradeOk(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pTradeOk_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTradeOk(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTradeOk_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeOk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTradeOk_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pTradeCancel(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pTradeCancel_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTradeCancel(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTradeCancel_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCancel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTradeCancel_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pTradeCommit(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pTradeCommit_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTradeCommit(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTradeCommit_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTradeCommit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTradeCommit_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pStopAttack(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pStopAttack_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pStopAttack(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pStopAttack_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStopAttack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pStopAttack_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPutItemToCart(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPutItemToCart_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPutItemToCart(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPutItemToCart_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPutItemToCart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPutItemToCart_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGetItemFromCart(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGetItemFromCart_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGetItemFromCart(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGetItemFromCart_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGetItemFromCart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGetItemFromCart_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRemoveOption(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRemoveOption_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRemoveOption(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRemoveOption_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemoveOption_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRemoveOption_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pChangeCart(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pChangeCart_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pChangeCart(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pChangeCart_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeCart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pChangeCart_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pStatusUp(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pStatusUp_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pStatusUp(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pStatusUp_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStatusUp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pStatusUp_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSkillUp(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSkillUp_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSkillUp(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSkillUp_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillUp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSkillUp_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pUseSkillToId(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillToId_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillToId(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pUseSkillToId_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pUseSkillToId_homun(struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillToId_homun_pre ) {
		void (*preHookFunc) (struct homun_data **hd, struct map_session_data **sd, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillToId_homun(hd, sd, tick, skill_id, skill_lv, target_id);
	}
	if( HPMHooks.count.HP_clif_pUseSkillToId_homun_post ) {
		void (*postHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_homun_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_homun_post[hIndex].func;
			postHookFunc(hd, sd, tick, skill_id, skill_lv, target_id);
		}
	}
	return;
}
void HP_clif_pUseSkillToId_mercenary(struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillToId_mercenary_pre ) {
		void (*preHookFunc) (struct mercenary_data **md, struct map_session_data **sd, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillToId_mercenary(md, sd, tick, skill_id, skill_lv, target_id);
	}
	if( HPMHooks.count.HP_clif_pUseSkillToId_mercenary_post ) {
		void (*postHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, int target_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToId_mercenary_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToId_mercenary_post[hIndex].func;
			postHookFunc(md, sd, tick, skill_id, skill_lv, target_id);
		}
	}
	return;
}
void HP_clif_pUseSkillToPos(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillToPos_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillToPos(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pUseSkillToPos_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pUseSkillToPosSub(int fd, struct map_session_data *sd, uint16 skill_lv, uint16 skill_id, short x, short y, int skillmoreinfo) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillToPosSub_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd, uint16 *skill_lv, uint16 *skill_id, short *x, short *y, int *skillmoreinfo);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillToPosSub(fd, sd, skill_lv, skill_id, x, y, skillmoreinfo);
	}
	if( HPMHooks.count.HP_clif_pUseSkillToPosSub_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd, uint16 skill_lv, uint16 skill_id, short x, short y, int skillmoreinfo);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosSub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosSub_post[hIndex].func;
			postHookFunc(fd, sd, skill_lv, skill_id, x, y, skillmoreinfo);
		}
	}
	return;
}
void HP_clif_pUseSkillToPos_homun(struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillToPos_homun_pre ) {
		void (*preHookFunc) (struct homun_data **hd, struct map_session_data **sd, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillToPos_homun(hd, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo);
	}
	if( HPMHooks.count.HP_clif_pUseSkillToPos_homun_post ) {
		void (*postHookFunc) (struct homun_data *hd, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_homun_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_homun_post[hIndex].func;
			postHookFunc(hd, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo);
		}
	}
	return;
}
void HP_clif_pUseSkillToPos_mercenary(struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_pre ) {
		void (*preHookFunc) (struct mercenary_data **md, struct map_session_data **sd, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillToPos_mercenary(md, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo);
	}
	if( HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_post ) {
		void (*postHookFunc) (struct mercenary_data *md, struct map_session_data *sd, int64 tick, uint16 skill_id, uint16 skill_lv, short x, short y, int skillmoreinfo);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPos_mercenary_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPos_mercenary_post[hIndex].func;
			postHookFunc(md, sd, tick, skill_id, skill_lv, x, y, skillmoreinfo);
		}
	}
	return;
}
void HP_clif_pUseSkillToPosMoreInfo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillToPosMoreInfo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillToPosMoreInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillToPosMoreInfo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pUseSkillMap(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseSkillMap_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseSkillMap(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pUseSkillMap_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseSkillMap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseSkillMap_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRequestMemo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRequestMemo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRequestMemo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRequestMemo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRequestMemo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRequestMemo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pProduceMix(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pProduceMix_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pProduceMix(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pProduceMix_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pProduceMix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pProduceMix_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCooking(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCooking_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCooking(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCooking_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCooking_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCooking_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRepairItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRepairItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRepairItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRepairItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRepairItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRepairItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pWeaponRefine(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pWeaponRefine_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pWeaponRefine(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pWeaponRefine_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pWeaponRefine_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pWeaponRefine_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcSelectMenu(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcSelectMenu_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcSelectMenu(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcSelectMenu_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcSelectMenu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcSelectMenu_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcNextClicked(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcNextClicked_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcNextClicked(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcNextClicked_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcNextClicked_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcNextClicked_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcAmountInput(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcAmountInput_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcAmountInput(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcAmountInput_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcAmountInput_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcAmountInput_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcStringInput(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcStringInput_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcStringInput(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcStringInput_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcStringInput_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcStringInput_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNpcCloseClicked(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNpcCloseClicked_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNpcCloseClicked(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNpcCloseClicked_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNpcCloseClicked_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNpcCloseClicked_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pItemIdentify(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pItemIdentify_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pItemIdentify(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pItemIdentify_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemIdentify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pItemIdentify_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSelectArrow(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSelectArrow_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSelectArrow(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSelectArrow_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectArrow_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSelectArrow_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAutoSpell(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAutoSpell_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAutoSpell(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAutoSpell_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoSpell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAutoSpell_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pUseCard(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pUseCard_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pUseCard(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pUseCard_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pUseCard_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pUseCard_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pInsertCard(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pInsertCard_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pInsertCard(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pInsertCard_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pInsertCard_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pInsertCard_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSolveCharName(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSolveCharName_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSolveCharName(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSolveCharName_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSolveCharName_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSolveCharName_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pResetChar(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pResetChar_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pResetChar(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pResetChar_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pResetChar_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pResetChar_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pLocalBroadcast(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pLocalBroadcast_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pLocalBroadcast(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pLocalBroadcast_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLocalBroadcast_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pLocalBroadcast_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMoveToKafra(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMoveToKafra_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMoveToKafra(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMoveToKafra_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafra_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMoveToKafra_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMoveFromKafra(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMoveFromKafra_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMoveFromKafra(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMoveFromKafra_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafra_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMoveFromKafra_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMoveToKafraFromCart(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMoveToKafraFromCart_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMoveToKafraFromCart(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMoveToKafraFromCart_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveToKafraFromCart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMoveToKafraFromCart_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMoveFromKafraToCart(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMoveFromKafraToCart_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMoveFromKafraToCart(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMoveFromKafraToCart_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveFromKafraToCart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMoveFromKafraToCart_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCloseKafra(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCloseKafra_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCloseKafra(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCloseKafra_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseKafra_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCloseKafra_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pStoragePassword(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pStoragePassword_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pStoragePassword(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pStoragePassword_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pStoragePassword_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pStoragePassword_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCreateParty(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCreateParty_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCreateParty(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCreateParty_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCreateParty_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCreateParty2(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCreateParty2_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCreateParty2(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCreateParty2_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateParty2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCreateParty2_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyInvite(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyInvite_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyInvite(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyInvite_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyInvite_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyInvite2(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyInvite2_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyInvite2(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyInvite2_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyInvite2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyInvite2_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pReplyPartyInvite(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pReplyPartyInvite_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pReplyPartyInvite(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pReplyPartyInvite_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pReplyPartyInvite2(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pReplyPartyInvite2_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pReplyPartyInvite2(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pReplyPartyInvite2_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReplyPartyInvite2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pReplyPartyInvite2_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pLeaveParty(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pLeaveParty_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pLeaveParty(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pLeaveParty_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLeaveParty_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pLeaveParty_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRemovePartyMember(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRemovePartyMember_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRemovePartyMember(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRemovePartyMember_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRemovePartyMember_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRemovePartyMember_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyChangeOption(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyChangeOption_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyChangeOption(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyChangeOption_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeOption_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyChangeOption_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyMessage(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyMessage_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyMessage(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyMessage_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyMessage_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyChangeLeader(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyChangeLeader_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyChangeLeader(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyChangeLeader_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyChangeLeader_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyChangeLeader_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingRegisterReq(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingRegisterReq_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingRegisterReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingRegisterReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRegisterReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingRegisterReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingSearchReq(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingSearchReq_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingSearchReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingSearchReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSearchReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingSearchReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingDeleteReq(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingDeleteReq_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingDeleteReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingDeleteReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingDeleteReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingDeleteReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingUpdateReq(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingUpdateReq_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingUpdateReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingUpdateReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingUpdateReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingUpdateReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyRecruitRegisterReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyRecruitRegisterReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitRegisterReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyRecruitRegisterReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyRecruitSearchReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyRecruitSearchReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitSearchReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyRecruitSearchReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyRecruitDeleteReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyRecruitDeleteReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitDeleteReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyRecruitDeleteReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyRecruitUpdateReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyRecruitUpdateReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyRecruitUpdateReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyRecruitUpdateReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCloseVending(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCloseVending_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCloseVending(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCloseVending_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseVending_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCloseVending_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pVendingListReq(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pVendingListReq_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pVendingListReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pVendingListReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pVendingListReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pVendingListReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPurchaseReq(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPurchaseReq_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPurchaseReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPurchaseReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPurchaseReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPurchaseReq2(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPurchaseReq2_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPurchaseReq2(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPurchaseReq2_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPurchaseReq2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPurchaseReq2_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pOpenVending(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pOpenVending_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pOpenVending(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pOpenVending_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOpenVending_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pOpenVending_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCreateGuild(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCreateGuild_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCreateGuild(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCreateGuild_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCreateGuild_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCreateGuild_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildCheckMaster(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildCheckMaster_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildCheckMaster(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildCheckMaster_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildCheckMaster_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildCheckMaster_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildRequestInfo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildRequestInfo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildRequestInfo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildRequestInfo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildRequestInfo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildChangePositionInfo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildChangePositionInfo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildChangePositionInfo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildChangePositionInfo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangePositionInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildChangePositionInfo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildChangeMemberPosition(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildChangeMemberPosition_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildChangeMemberPosition(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildChangeMemberPosition_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeMemberPosition_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildChangeMemberPosition_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildRequestEmblem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildRequestEmblem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildRequestEmblem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildRequestEmblem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestEmblem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildRequestEmblem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildChangeEmblem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildChangeEmblem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildChangeEmblem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildChangeEmblem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeEmblem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildChangeEmblem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildChangeNotice(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildChangeNotice_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildChangeNotice(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildChangeNotice_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildChangeNotice_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildChangeNotice_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildInvite(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildInvite_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildInvite(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildInvite_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildInvite_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildReplyInvite(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildReplyInvite_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildReplyInvite(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildReplyInvite_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyInvite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildReplyInvite_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildLeave(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildLeave_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildLeave(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildLeave_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildLeave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildLeave_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildExpulsion(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildExpulsion_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildExpulsion(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildExpulsion_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildExpulsion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildExpulsion_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildMessage(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildMessage_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildMessage(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildMessage_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildMessage_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildRequestAlliance(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildRequestAlliance_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildRequestAlliance(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildRequestAlliance_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildRequestAlliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildRequestAlliance_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildReplyAlliance(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildReplyAlliance_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildReplyAlliance(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildReplyAlliance_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildReplyAlliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildReplyAlliance_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildDelAlliance(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildDelAlliance_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildDelAlliance(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildDelAlliance_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildDelAlliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildDelAlliance_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildOpposition(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildOpposition_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildOpposition(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildOpposition_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildOpposition_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildOpposition_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildBreak(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildBreak_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildBreak(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildBreak_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildBreak_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildBreak_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPetMenu(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPetMenu_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPetMenu(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPetMenu_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPetMenu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPetMenu_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCatchPet(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCatchPet_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCatchPet(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCatchPet_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCatchPet_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCatchPet_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSelectEgg(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSelectEgg_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSelectEgg(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSelectEgg_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectEgg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSelectEgg_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSendEmotion(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSendEmotion_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSendEmotion(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSendEmotion_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSendEmotion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSendEmotion_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pChangePetName(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pChangePetName_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pChangePetName(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pChangePetName_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangePetName_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pChangePetName_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMKick(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMKick_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMKick(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMKick_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMKick_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMKickAll(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMKickAll_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMKickAll(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMKickAll_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMKickAll_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMKickAll_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMShift(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMShift_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMShift(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMShift_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMShift_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMShift_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMRemove2(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMRemove2_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMRemove2(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMRemove2_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRemove2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMRemove2_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMRecall(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMRecall_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMRecall(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMRecall_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMRecall_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMRecall2(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMRecall2_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMRecall2(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMRecall2_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRecall2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMRecall2_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGM_Monster_Item(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGM_Monster_Item_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGM_Monster_Item(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGM_Monster_Item_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGM_Monster_Item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGM_Monster_Item_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMHide(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMHide_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMHide(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMHide_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMHide_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMHide_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMReqNoChat(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMReqNoChat_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMReqNoChat(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMReqNoChat_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqNoChat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMReqNoChat_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMRc(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMRc_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMRc(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMRc_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMRc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMRc_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMReqAccountName(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMReqAccountName_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMReqAccountName(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMReqAccountName_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMReqAccountName_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMReqAccountName_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGMChangeMapType(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGMChangeMapType_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMChangeMapType(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMChangeMapType_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMChangeMapType_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMChangeMapType_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGMFullStrip(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGMFullStrip_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGMFullStrip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGMFullStrip_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPMIgnore(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPMIgnore_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPMIgnore(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPMIgnore_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnore_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPMIgnore_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPMIgnoreAll(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPMIgnoreAll_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPMIgnoreAll(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPMIgnoreAll_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreAll_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPMIgnoreAll_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPMIgnoreList(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPMIgnoreList_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPMIgnoreList(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPMIgnoreList_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPMIgnoreList_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPMIgnoreList_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNoviceDoriDori(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNoviceDoriDori_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNoviceDoriDori(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNoviceDoriDori_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceDoriDori_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNoviceDoriDori_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pNoviceExplosionSpirits(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pNoviceExplosionSpirits_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNoviceExplosionSpirits(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNoviceExplosionSpirits_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNoviceExplosionSpirits_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNoviceExplosionSpirits_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pFriendsListAdd(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pFriendsListAdd_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pFriendsListAdd(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pFriendsListAdd_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListAdd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pFriendsListAdd_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pFriendsListReply(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pFriendsListReply_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pFriendsListReply(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pFriendsListReply_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListReply_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pFriendsListReply_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pFriendsListRemove(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pFriendsListRemove_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pFriendsListRemove(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pFriendsListRemove_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFriendsListRemove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pFriendsListRemove_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPVPInfo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPVPInfo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPVPInfo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPVPInfo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPVPInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPVPInfo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pBlacksmith(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pBlacksmith_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBlacksmith(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBlacksmith_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBlacksmith_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBlacksmith_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAlchemist(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAlchemist_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAlchemist(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAlchemist_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAlchemist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAlchemist_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pTaekwon(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pTaekwon_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pTaekwon(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pTaekwon_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pTaekwon_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pTaekwon_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRankingPk(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRankingPk_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRankingPk(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRankingPk_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRankingPk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRankingPk_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pFeelSaveOk(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pFeelSaveOk_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pFeelSaveOk(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pFeelSaveOk_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pFeelSaveOk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pFeelSaveOk_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pChangeHomunculusName(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pChangeHomunculusName_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pChangeHomunculusName(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pChangeHomunculusName_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pChangeHomunculusName_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pChangeHomunculusName_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pHomMoveToMaster(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pHomMoveToMaster_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pHomMoveToMaster(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pHomMoveToMaster_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveToMaster_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pHomMoveToMaster_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pHomMoveTo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pHomMoveTo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pHomMoveTo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pHomMoveTo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMoveTo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pHomMoveTo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pHomAttack(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pHomAttack_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pHomAttack(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pHomAttack_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomAttack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pHomAttack_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pHomMenu(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pHomMenu_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pHomMenu(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pHomMenu_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHomMenu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pHomMenu_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAutoRevive(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAutoRevive_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAutoRevive(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAutoRevive_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAutoRevive_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAutoRevive_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCheck(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCheck_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCheck(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCheck_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCheck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCheck_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMail_refreshinbox(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMail_refreshinbox_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMail_refreshinbox(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMail_refreshinbox_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_refreshinbox_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMail_refreshinbox_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMail_read(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMail_read_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMail_read(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMail_read_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMail_read_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMail_getattach(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMail_getattach_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMail_getattach(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMail_getattach_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_getattach_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMail_getattach_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMail_delete(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMail_delete_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMail_delete(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMail_delete_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMail_delete_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMail_return(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMail_return_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMail_return(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMail_return_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_return_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMail_return_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMail_setattach(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMail_setattach_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMail_setattach(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMail_setattach_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_setattach_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMail_setattach_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMail_winopen(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMail_winopen_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMail_winopen(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMail_winopen_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_winopen_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMail_winopen_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMail_send(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMail_send_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMail_send(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMail_send_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMail_send_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMail_send_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAuction_cancelreg(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAuction_cancelreg_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAuction_cancelreg(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAuction_cancelreg_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancelreg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAuction_cancelreg_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAuction_setitem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAuction_setitem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAuction_setitem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAuction_setitem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_setitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAuction_setitem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAuction_register(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAuction_register_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAuction_register(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAuction_register_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_register_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAuction_register_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAuction_cancel(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAuction_cancel_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAuction_cancel(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAuction_cancel_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_cancel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAuction_cancel_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAuction_close(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAuction_close_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAuction_close(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAuction_close_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAuction_close_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAuction_bid(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAuction_bid_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAuction_bid(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAuction_bid_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_bid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAuction_bid_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAuction_search(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAuction_search_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAuction_search(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAuction_search_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAuction_search_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAuction_buysell(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAuction_buysell_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAuction_buysell(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAuction_buysell_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAuction_buysell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAuction_buysell_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pcashshop_buy(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pcashshop_buy_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pcashshop_buy(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pcashshop_buy_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pcashshop_buy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pcashshop_buy_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAdopt_request(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAdopt_request_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAdopt_request(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAdopt_request_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_request_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAdopt_request_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pAdopt_reply(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pAdopt_reply_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pAdopt_reply(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pAdopt_reply_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pAdopt_reply_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pAdopt_reply_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pViewPlayerEquip(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pViewPlayerEquip_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pViewPlayerEquip(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pViewPlayerEquip_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pViewPlayerEquip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pViewPlayerEquip_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pEquipTick(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pEquipTick_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pEquipTick(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pEquipTick_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pEquipTick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pEquipTick_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pquestStateAck(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pquestStateAck_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pquestStateAck(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pquestStateAck_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pquestStateAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pquestStateAck_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pmercenary_action(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pmercenary_action_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pmercenary_action(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pmercenary_action_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pmercenary_action_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pmercenary_action_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pBattleChat(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pBattleChat_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBattleChat(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBattleChat_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBattleChat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBattleChat_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pLessEffect(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pLessEffect_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pLessEffect(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pLessEffect_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pLessEffect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pLessEffect_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pItemListWindowSelected(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pItemListWindowSelected_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pItemListWindowSelected(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pItemListWindowSelected_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pItemListWindowSelected_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pItemListWindowSelected_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pReqOpenBuyingStore(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pReqOpenBuyingStore_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pReqOpenBuyingStore(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pReqOpenBuyingStore_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqOpenBuyingStore_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pReqOpenBuyingStore_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pReqCloseBuyingStore(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pReqCloseBuyingStore_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pReqCloseBuyingStore(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pReqCloseBuyingStore_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqCloseBuyingStore_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pReqCloseBuyingStore_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pReqClickBuyingStore(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pReqClickBuyingStore_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pReqClickBuyingStore(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pReqClickBuyingStore_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqClickBuyingStore_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pReqClickBuyingStore_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pReqTradeBuyingStore(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pReqTradeBuyingStore_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pReqTradeBuyingStore(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pReqTradeBuyingStore_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pReqTradeBuyingStore_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pReqTradeBuyingStore_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSearchStoreInfo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSearchStoreInfo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSearchStoreInfo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSearchStoreInfo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSearchStoreInfoNextPage(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSearchStoreInfoNextPage(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoNextPage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoNextPage_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCloseSearchStoreInfo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCloseSearchStoreInfo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCloseSearchStoreInfo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCloseSearchStoreInfo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCloseSearchStoreInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCloseSearchStoreInfo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSearchStoreInfoListItemClick(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSearchStoreInfoListItemClick(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSearchStoreInfoListItemClick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSearchStoreInfoListItemClick_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pDebug(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pDebug_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pDebug(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pDebug_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDebug_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pDebug_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pSkillSelectMenu(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSkillSelectMenu_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSkillSelectMenu(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSkillSelectMenu_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSkillSelectMenu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSkillSelectMenu_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pMoveItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pMoveItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pMoveItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pMoveItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pMoveItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pMoveItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pDull(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pDull_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pDull(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pDull_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pDull_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pDull_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pBGQueueRegister(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pBGQueueRegister_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBGQueueRegister(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBGQueueRegister_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRegister_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBGQueueRegister_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pBGQueueCheckState(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pBGQueueCheckState_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBGQueueCheckState(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBGQueueCheckState_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueCheckState_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBGQueueCheckState_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pBGQueueRevokeReq(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pBGQueueRevokeReq_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBGQueueRevokeReq(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBGQueueRevokeReq_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueRevokeReq_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBGQueueRevokeReq_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pBGQueueBattleBeginAck(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBGQueueBattleBeginAck(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBGQueueBattleBeginAck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBGQueueBattleBeginAck_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCashShopOpen(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCashShopOpen_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCashShopOpen(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCashShopOpen_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopOpen_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCashShopOpen_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCashShopClose(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCashShopClose_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCashShopClose(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCashShopClose_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopClose_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCashShopClose_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCashShopReqTab(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCashShopReqTab_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCashShopReqTab(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCashShopReqTab_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopReqTab_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCashShopReqTab_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCashShopSchedule(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCashShopSchedule_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCashShopSchedule(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCashShopSchedule_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopSchedule_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCashShopSchedule_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pCashShopBuy(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pCashShopBuy_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pCashShopBuy(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pCashShopBuy_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pCashShopBuy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pCashShopBuy_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyTick(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyTick_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyTick(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyTick_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyTick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyTick_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pGuildInvite2(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pGuildInvite2_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pGuildInvite2(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pGuildInvite2_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pGuildInvite2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pGuildInvite2_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingAddFilter(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingAddFilter_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingAddFilter(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingAddFilter_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingAddFilter_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingAddFilter_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingSubFilter(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingSubFilter_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingSubFilter(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingSubFilter_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingSubFilter_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingSubFilter_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingReqVolunteer(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingReqVolunteer(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingReqVolunteer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingReqVolunteer_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingRefuseVolunteer(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingRefuseVolunteer(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingRefuseVolunteer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingRefuseVolunteer_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pPartyBookingCancelVolunteer(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pPartyBookingCancelVolunteer(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pPartyBookingCancelVolunteer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pPartyBookingCancelVolunteer_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBankDeposit(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBankDeposit_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankDeposit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBankDeposit_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBankWithdraw(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBankWithdraw_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankWithdraw_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBankWithdraw_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBankCheck(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBankCheck_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankCheck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBankCheck_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBankOpen(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBankOpen_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankOpen_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBankOpen_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pBankClose(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pBankClose_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pBankClose_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pBankClose_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRouletteOpen(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRouletteOpen_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteOpen_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_pRouletteOpen_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRouletteOpen(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRouletteOpen_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteOpen_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRouletteOpen_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRouletteInfo(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRouletteInfo_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteInfo_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_pRouletteInfo_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRouletteInfo(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRouletteInfo_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRouletteInfo_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRouletteClose(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRouletteClose_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteClose_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_pRouletteClose_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRouletteClose(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRouletteClose_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteClose_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRouletteClose_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRouletteGenerate(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRouletteGenerate_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteGenerate_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_pRouletteGenerate_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRouletteGenerate(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRouletteGenerate_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteGenerate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRouletteGenerate_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_pRouletteRecvItem(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pRouletteRecvItem_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteRecvItem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_pRouletteRecvItem_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pRouletteRecvItem(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pRouletteRecvItem_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pRouletteRecvItem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pRouletteRecvItem_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNPCShopClosed(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNPCShopClosed_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCShopClosed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNPCShopClosed_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNPCMarketClosed(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNPCMarketClosed_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCMarketClosed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNPCMarketClosed_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pNPCMarketPurchase(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pNPCMarketPurchase_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pNPCMarketPurchase_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pNPCMarketPurchase_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_add_random_options(unsigned char *buf, struct item *item) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_add_random_options_pre ) {
		void (*preHookFunc) (unsigned char **buf, struct item **item);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_add_random_options_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_add_random_options_pre[hIndex].func;
			preHookFunc(&buf, &item);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.add_random_options(buf, item);
	}
	if( HPMHooks.count.HP_clif_add_random_options_post ) {
		void (*postHookFunc) (unsigned char *buf, struct item *item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_add_random_options_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_add_random_options_post[hIndex].func;
			postHookFunc(buf, item);
		}
	}
	return;
}
void HP_clif_pHotkeyRowShift(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pHotkeyRowShift_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkeyRowShift_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_pHotkeyRowShift_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pHotkeyRowShift(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pHotkeyRowShift_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pHotkeyRowShift_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pHotkeyRowShift_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_dressroom_open(struct map_session_data *sd, int view) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_dressroom_open_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *view);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dressroom_open_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_dressroom_open_pre[hIndex].func;
			preHookFunc(&sd, &view);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.dressroom_open(sd, view);
	}
	if( HPMHooks.count.HP_clif_dressroom_open_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int view);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_dressroom_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_dressroom_open_post[hIndex].func;
			postHookFunc(sd, view);
		}
	}
	return;
}
void HP_clif_pOneClick_ItemIdentify(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pOneClick_ItemIdentify_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOneClick_ItemIdentify_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_pOneClick_ItemIdentify_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pOneClick_ItemIdentify(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pOneClick_ItemIdentify_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pOneClick_ItemIdentify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pOneClick_ItemIdentify_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
void HP_clif_selectcart(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_selectcart_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_selectcart_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_selectcart_pre[hIndex].func;
			preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.selectcart(sd);
	}
	if( HPMHooks.count.HP_clif_selectcart_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_selectcart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_selectcart_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_clif_pSelectCart(int fd, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_clif_pSelectCart_pre ) {
		void (*preHookFunc) (int *fd, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectCart_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_pSelectCart_pre[hIndex].func;
			preHookFunc(&fd, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.clif.pSelectCart(fd, sd);
	}
	if( HPMHooks.count.HP_clif_pSelectCart_post ) {
		void (*postHookFunc) (int fd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_pSelectCart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_pSelectCart_post[hIndex].func;
			postHookFunc(fd, sd);
		}
	}
	return;
}
const char* HP_clif_get_bl_name(const struct block_list *bl) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_clif_get_bl_name_pre ) {
		const char* (*preHookFunc) (const struct block_list **bl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_get_bl_name_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_clif_get_bl_name_pre[hIndex].func;
			retVal___ = preHookFunc(&bl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.clif.get_bl_name(bl);
	}
	if( HPMHooks.count.HP_clif_get_bl_name_post ) {
		const char* (*postHookFunc) (const char* retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_clif_get_bl_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_clif_get_bl_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
/* cmdline_interface */
void HP_cmdline_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_cmdline_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_cmdline_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.cmdline.init();
	}
	if( HPMHooks.count.HP_cmdline_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_cmdline_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_cmdline_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_cmdline_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_cmdline_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.cmdline.final();
	}
	if( HPMHooks.count.HP_cmdline_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_cmdline_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_cmdline_arg_add(unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_cmdline_arg_add_pre ) {
		bool (*preHookFunc) (unsigned int *pluginID, const char **name, char *shortname, CmdlineExecFunc *func, const char **help, unsigned int *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_cmdline_arg_add_pre[hIndex].func;
			retVal___ = preHookFunc(&pluginID, &name, &shortname, &func, &help, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.cmdline.arg_add(pluginID, name, shortname, func, help, options);
	}
	if( HPMHooks.count.HP_cmdline_arg_add_post ) {
		bool (*postHookFunc) (bool retVal___, unsigned int pluginID, const char *name, char shortname, CmdlineExecFunc func, const char *help, unsigned int options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_cmdline_arg_add_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pluginID, name, shortname, func, help, options);
		}
	}
	return retVal___;
}
int HP_cmdline_exec(int argc, char **argv, unsigned int options) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_cmdline_exec_pre ) {
		int (*preHookFunc) (int *argc, char ***argv, unsigned int *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_cmdline_exec_pre[hIndex].func;
			retVal___ = preHookFunc(&argc, &argv, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.cmdline.exec(argc, argv, options);
	}
	if( HPMHooks.count.HP_cmdline_exec_post ) {
		int (*postHookFunc) (int retVal___, int argc, char **argv, unsigned int options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_exec_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_cmdline_exec_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, argc, argv, options);
		}
	}
	return retVal___;
}
bool HP_cmdline_arg_next_value(const char *name, int current_arg, int argc) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_cmdline_arg_next_value_pre ) {
		bool (*preHookFunc) (const char **name, int *current_arg, int *argc);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_pre[hIndex].func;
			retVal___ = preHookFunc(&name, &current_arg, &argc);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.cmdline.arg_next_value(name, current_arg, argc);
	}
	if( HPMHooks.count.HP_cmdline_arg_next_value_post ) {
		bool (*postHookFunc) (bool retVal___, const char *name, int current_arg, int argc);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_next_value_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_cmdline_arg_next_value_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, current_arg, argc);
		}
	}
	return retVal___;
}
const char* HP_cmdline_arg_source(struct CmdlineArgData *arg) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_cmdline_arg_source_pre ) {
		const char* (*preHookFunc) (struct CmdlineArgData **arg);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_cmdline_arg_source_pre[hIndex].func;
			retVal___ = preHookFunc(&arg);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.cmdline.arg_source(arg);
	}
	if( HPMHooks.count.HP_cmdline_arg_source_post ) {
		const char* (*postHookFunc) (const char* retVal___, struct CmdlineArgData *arg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_cmdline_arg_source_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_cmdline_arg_source_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, arg);
		}
	}
	return retVal___;
}
/* console_interface */
void HP_console_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_console_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_console_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_console_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.console.init();
	}
	if( HPMHooks.count.HP_console_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_console_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_console_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_console_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_console_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_console_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_console_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.console.final();
	}
	if( HPMHooks.count.HP_console_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_console_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_console_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_console_display_title(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_console_display_title_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_title_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_console_display_title_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.console.display_title();
	}
	if( HPMHooks.count.HP_console_display_title_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_title_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_console_display_title_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_console_display_gplnotice(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_console_display_gplnotice_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_gplnotice_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_console_display_gplnotice_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.console.display_gplnotice();
	}
	if( HPMHooks.count.HP_console_display_gplnotice_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_console_display_gplnotice_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_console_display_gplnotice_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* core_interface */
void HP_core_shutdown_callback(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_core_shutdown_callback_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_core_shutdown_callback_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_core_shutdown_callback_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.core.shutdown_callback();
	}
	if( HPMHooks.count.HP_core_shutdown_callback_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_core_shutdown_callback_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_core_shutdown_callback_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* db_interface */
enum DBOptions HP_DB_fix_options(enum DBType type, enum DBOptions options) {
	int hIndex = 0;
	enum DBOptions retVal___ = DB_OPT_BASE;
	if( HPMHooks.count.HP_DB_fix_options_pre ) {
		enum DBOptions (*preHookFunc) (enum DBType *type, enum DBOptions *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_fix_options_pre[hIndex].func;
			retVal___ = preHookFunc(&type, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.fix_options(type, options);
	}
	if( HPMHooks.count.HP_DB_fix_options_post ) {
		enum DBOptions (*postHookFunc) (enum DBOptions retVal___, enum DBType type, enum DBOptions options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_fix_options_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_fix_options_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type, options);
		}
	}
	return retVal___;
}
DBComparator HP_DB_default_cmp(enum DBType type) {
	int hIndex = 0;
	DBComparator retVal___ = NULL;
	if( HPMHooks.count.HP_DB_default_cmp_pre ) {
		DBComparator (*preHookFunc) (enum DBType *type);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_default_cmp_pre[hIndex].func;
			retVal___ = preHookFunc(&type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.default_cmp(type);
	}
	if( HPMHooks.count.HP_DB_default_cmp_post ) {
		DBComparator (*postHookFunc) (DBComparator retVal___, enum DBType type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_cmp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_default_cmp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type);
		}
	}
	return retVal___;
}
DBHasher HP_DB_default_hash(enum DBType type) {
	int hIndex = 0;
	DBHasher retVal___ = NULL;
	if( HPMHooks.count.HP_DB_default_hash_pre ) {
		DBHasher (*preHookFunc) (enum DBType *type);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_default_hash_pre[hIndex].func;
			retVal___ = preHookFunc(&type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.default_hash(type);
	}
	if( HPMHooks.count.HP_DB_default_hash_post ) {
		DBHasher (*postHookFunc) (DBHasher retVal___, enum DBType type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_hash_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_default_hash_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type);
		}
	}
	return retVal___;
}
DBReleaser HP_DB_default_release(enum DBType type, enum DBOptions options) {
	int hIndex = 0;
	DBReleaser retVal___ = NULL;
	if( HPMHooks.count.HP_DB_default_release_pre ) {
		DBReleaser (*preHookFunc) (enum DBType *type, enum DBOptions *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_default_release_pre[hIndex].func;
			retVal___ = preHookFunc(&type, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.default_release(type, options);
	}
	if( HPMHooks.count.HP_DB_default_release_post ) {
		DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBType type, enum DBOptions options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_default_release_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_default_release_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type, options);
		}
	}
	return retVal___;
}
DBReleaser HP_DB_custom_release(enum DBReleaseOption which) {
	int hIndex = 0;
	DBReleaser retVal___ = NULL;
	if( HPMHooks.count.HP_DB_custom_release_pre ) {
		DBReleaser (*preHookFunc) (enum DBReleaseOption *which);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_custom_release_pre[hIndex].func;
			retVal___ = preHookFunc(&which);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.custom_release(which);
	}
	if( HPMHooks.count.HP_DB_custom_release_post ) {
		DBReleaser (*postHookFunc) (DBReleaser retVal___, enum DBReleaseOption which);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_custom_release_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_custom_release_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, which);
		}
	}
	return retVal___;
}
struct DBMap* HP_DB_alloc(const char *file, const char *func, int line, enum DBType type, enum DBOptions options, unsigned short maxlen) {
	int hIndex = 0;
	struct DBMap* retVal___ = NULL;
	if( HPMHooks.count.HP_DB_alloc_pre ) {
		struct DBMap* (*preHookFunc) (const char **file, const char **func, int *line, enum DBType *type, enum DBOptions *options, unsigned short *maxlen);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_alloc_pre[hIndex].func;
			retVal___ = preHookFunc(&file, &func, &line, &type, &options, &maxlen);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.alloc(file, func, line, type, options, maxlen);
	}
	if( HPMHooks.count.HP_DB_alloc_post ) {
		struct DBMap* (*postHookFunc) (struct DBMap* retVal___, const char *file, const char *func, int line, enum DBType type, enum DBOptions options, unsigned short maxlen);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_alloc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_alloc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, file, func, line, type, options, maxlen);
		}
	}
	return retVal___;
}
union DBKey HP_DB_i2key(int key) {
	int hIndex = 0;
	union DBKey retVal___ = { 0 };
	if( HPMHooks.count.HP_DB_i2key_pre ) {
		union DBKey (*preHookFunc) (int *key);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_i2key_pre[hIndex].func;
			retVal___ = preHookFunc(&key);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.i2key(key);
	}
	if( HPMHooks.count.HP_DB_i2key_post ) {
		union DBKey (*postHookFunc) (union DBKey retVal___, int key);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2key_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_i2key_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key);
		}
	}
	return retVal___;
}
union DBKey HP_DB_ui2key(unsigned int key) {
	int hIndex = 0;
	union DBKey retVal___ = { 0 };
	if( HPMHooks.count.HP_DB_ui2key_pre ) {
		union DBKey (*preHookFunc) (unsigned int *key);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_ui2key_pre[hIndex].func;
			retVal___ = preHookFunc(&key);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.ui2key(key);
	}
	if( HPMHooks.count.HP_DB_ui2key_post ) {
		union DBKey (*postHookFunc) (union DBKey retVal___, unsigned int key);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2key_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_ui2key_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key);
		}
	}
	return retVal___;
}
union DBKey HP_DB_str2key(const char *key) {
	int hIndex = 0;
	union DBKey retVal___ = { 0 };
	if( HPMHooks.count.HP_DB_str2key_pre ) {
		union DBKey (*preHookFunc) (const char **key);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_str2key_pre[hIndex].func;
			retVal___ = preHookFunc(&key);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.str2key(key);
	}
	if( HPMHooks.count.HP_DB_str2key_post ) {
		union DBKey (*postHookFunc) (union DBKey retVal___, const char *key);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_str2key_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_str2key_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key);
		}
	}
	return retVal___;
}
union DBKey HP_DB_i642key(int64 key) {
	int hIndex = 0;
	union DBKey retVal___ = { 0 };
	if( HPMHooks.count.HP_DB_i642key_pre ) {
		union DBKey (*preHookFunc) (int64 *key);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_i642key_pre[hIndex].func;
			retVal___ = preHookFunc(&key);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.i642key(key);
	}
	if( HPMHooks.count.HP_DB_i642key_post ) {
		union DBKey (*postHookFunc) (union DBKey retVal___, int64 key);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i642key_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_i642key_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key);
		}
	}
	return retVal___;
}
union DBKey HP_DB_ui642key(uint64 key) {
	int hIndex = 0;
	union DBKey retVal___ = { 0 };
	if( HPMHooks.count.HP_DB_ui642key_pre ) {
		union DBKey (*preHookFunc) (uint64 *key);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_ui642key_pre[hIndex].func;
			retVal___ = preHookFunc(&key);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.ui642key(key);
	}
	if( HPMHooks.count.HP_DB_ui642key_post ) {
		union DBKey (*postHookFunc) (union DBKey retVal___, uint64 key);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui642key_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_ui642key_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key);
		}
	}
	return retVal___;
}
struct DBData HP_DB_i2data(int data) {
	int hIndex = 0;
	struct DBData retVal___ = { 0 };
	if( HPMHooks.count.HP_DB_i2data_pre ) {
		struct DBData (*preHookFunc) (int *data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_i2data_pre[hIndex].func;
			retVal___ = preHookFunc(&data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.i2data(data);
	}
	if( HPMHooks.count.HP_DB_i2data_post ) {
		struct DBData (*postHookFunc) (struct DBData retVal___, int data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_i2data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_i2data_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
struct DBData HP_DB_ui2data(unsigned int data) {
	int hIndex = 0;
	struct DBData retVal___ = { 0 };
	if( HPMHooks.count.HP_DB_ui2data_pre ) {
		struct DBData (*preHookFunc) (unsigned int *data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_ui2data_pre[hIndex].func;
			retVal___ = preHookFunc(&data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.ui2data(data);
	}
	if( HPMHooks.count.HP_DB_ui2data_post ) {
		struct DBData (*postHookFunc) (struct DBData retVal___, unsigned int data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ui2data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_ui2data_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
struct DBData HP_DB_ptr2data(void *data) {
	int hIndex = 0;
	struct DBData retVal___ = { 0 };
	if( HPMHooks.count.HP_DB_ptr2data_pre ) {
		struct DBData (*preHookFunc) (void **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_ptr2data_pre[hIndex].func;
			retVal___ = preHookFunc(&data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.ptr2data(data);
	}
	if( HPMHooks.count.HP_DB_ptr2data_post ) {
		struct DBData (*postHookFunc) (struct DBData retVal___, void *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_ptr2data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_ptr2data_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
int HP_DB_data2i(struct DBData *data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_DB_data2i_pre ) {
		int (*preHookFunc) (struct DBData **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_data2i_pre[hIndex].func;
			retVal___ = preHookFunc(&data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.data2i(data);
	}
	if( HPMHooks.count.HP_DB_data2i_post ) {
		int (*postHookFunc) (int retVal___, struct DBData *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2i_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_data2i_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
unsigned int HP_DB_data2ui(struct DBData *data) {
	int hIndex = 0;
	unsigned int retVal___ = 0;
	if( HPMHooks.count.HP_DB_data2ui_pre ) {
		unsigned int (*preHookFunc) (struct DBData **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_data2ui_pre[hIndex].func;
			retVal___ = preHookFunc(&data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.data2ui(data);
	}
	if( HPMHooks.count.HP_DB_data2ui_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, struct DBData *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ui_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_data2ui_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
void* HP_DB_data2ptr(struct DBData *data) {
	int hIndex = 0;
	void* retVal___ = NULL;
	if( HPMHooks.count.HP_DB_data2ptr_pre ) {
		void* (*preHookFunc) (struct DBData **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_data2ptr_pre[hIndex].func;
			retVal___ = preHookFunc(&data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.DB.data2ptr(data);
	}
	if( HPMHooks.count.HP_DB_data2ptr_post ) {
		void* (*postHookFunc) (void* retVal___, struct DBData *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_data2ptr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_data2ptr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
void HP_DB_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_DB_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.DB.init();
	}
	if( HPMHooks.count.HP_DB_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_DB_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_DB_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_DB_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.DB.final();
	}
	if( HPMHooks.count.HP_DB_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_DB_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_DB_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* des_interface */
void HP_des_decrypt_block(struct des_bit64 *block) {
	int hIndex = 0;
	if( HPMHooks.count.HP_des_decrypt_block_pre ) {
		void (*preHookFunc) (struct des_bit64 **block);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_des_decrypt_block_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_des_decrypt_block_pre[hIndex].func;
			preHookFunc(&block);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.des.decrypt_block(block);
	}
	if( HPMHooks.count.HP_des_decrypt_block_post ) {
		void (*postHookFunc) (struct des_bit64 *block);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_des_decrypt_block_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_des_decrypt_block_post[hIndex].func;
			postHookFunc(block);
		}
	}
	return;
}
void HP_des_decrypt(unsigned char *data, size_t size) {
	int hIndex = 0;
	if( HPMHooks.count.HP_des_decrypt_pre ) {
		void (*preHookFunc) (unsigned char **data, size_t *size);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_des_decrypt_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_des_decrypt_pre[hIndex].func;
			preHookFunc(&data, &size);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.des.decrypt(data, size);
	}
	if( HPMHooks.count.HP_des_decrypt_post ) {
		void (*postHookFunc) (unsigned char *data, size_t size);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_des_decrypt_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_des_decrypt_post[hIndex].func;
			postHookFunc(data, size);
		}
	}
	return;
}
/* duel_interface */
int HP_duel_create(struct map_session_data *sd, const unsigned int maxpl) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.duel.create(sd, maxpl);
	}
	if( HPMHooks.count.HP_duel_create_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const unsigned int maxpl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, maxpl);
		}
	}
	return retVal___;
}
void HP_duel_invite(const unsigned int did, struct map_session_data *sd, struct map_session_data *target_sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_duel_invite_pre ) {
		void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd, struct map_session_data **target_sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.duel.invite(did, sd, target_sd);
	}
	if( HPMHooks.count.HP_duel_invite_post ) {
		void (*postHookFunc) (const unsigned int did, struct map_session_data *sd, struct map_session_data *target_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_invite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_invite_post[hIndex].func;
			postHookFunc(did, sd, target_sd);
		}
	}
	return;
}
void HP_duel_accept(const unsigned int did, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_duel_accept_pre ) {
		void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.duel.accept(did, sd);
	}
	if( HPMHooks.count.HP_duel_accept_post ) {
		void (*postHookFunc) (const unsigned int did, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_accept_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_accept_post[hIndex].func;
			postHookFunc(did, sd);
		}
	}
	return;
}
void HP_duel_reject(const unsigned int did, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_duel_reject_pre ) {
		void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.duel.reject(did, sd);
	}
	if( HPMHooks.count.HP_duel_reject_post ) {
		void (*postHookFunc) (const unsigned int did, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_reject_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_reject_post[hIndex].func;
			postHookFunc(did, sd);
		}
	}
	return;
}
void HP_duel_leave(const unsigned int did, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_duel_leave_pre ) {
		void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.duel.leave(did, sd);
	}
	if( HPMHooks.count.HP_duel_leave_post ) {
		void (*postHookFunc) (const unsigned int did, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_leave_post[hIndex].func;
			postHookFunc(did, sd);
		}
	}
	return;
}
void HP_duel_showinfo(const unsigned int did, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_duel_showinfo_pre ) {
		void (*preHookFunc) (const unsigned int *did, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.duel.showinfo(did, sd);
	}
	if( HPMHooks.count.HP_duel_showinfo_post ) {
		void (*postHookFunc) (const unsigned int did, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_showinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_showinfo_post[hIndex].func;
			postHookFunc(did, sd);
		}
	}
	return;
}
int HP_duel_checktime(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.duel.checktime(sd);
	}
	if( HPMHooks.count.HP_duel_checktime_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_checktime_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_checktime_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_duel_init(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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.duel.init(minimal);
	}
	if( HPMHooks.count.HP_duel_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.duel.final();
	}
	if( HPMHooks.count.HP_duel_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_duel_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_duel_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* elemental_interface */
int HP_elemental_init(bool minimal) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.init(minimal);
	}
	if( HPMHooks.count.HP_elemental_init_post ) {
		int (*postHookFunc) (int retVal___, bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, minimal);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.elemental.final();
	}
	if( HPMHooks.count.HP_elemental_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_elemental_class(int class_) {
	int hIndex = 0;
	bool retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.class(class_);
	}
	if( HPMHooks.count.HP_elemental_class_post ) {
		bool (*postHookFunc) (bool retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_class_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_class_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
struct view_data* HP_elemental_get_viewdata(int class_) {
	int hIndex = 0;
	struct view_data* retVal___ = NULL;
	if( HPMHooks.count.HP_elemental_get_viewdata_pre ) {
		struct view_data* (*preHookFunc) (int *class_);
		*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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.get_viewdata(class_);
	}
	if( HPMHooks.count.HP_elemental_get_viewdata_post ) {
		struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_get_viewdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_get_viewdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
int HP_elemental_create(struct map_session_data *sd, int class_, unsigned int lifetime) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.create(sd, class_, lifetime);
	}
	if( HPMHooks.count.HP_elemental_create_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int class_, unsigned int lifetime);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, class_, lifetime);
		}
	}
	return retVal___;
}
int HP_elemental_data_received(const struct s_elemental *ele, bool flag) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_elemental_data_received_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.data_received(ele, flag);
	}
	if( HPMHooks.count.HP_elemental_data_received_post ) {
		int (*postHookFunc) (int retVal___, const struct s_elemental *ele, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_data_received_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_data_received_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ele, flag);
		}
	}
	return retVal___;
}
int HP_elemental_save(struct elemental_data *ed) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.save(ed);
	}
	if( HPMHooks.count.HP_elemental_save_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_save_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed);
		}
	}
	return retVal___;
}
int HP_elemental_change_mode_ack(struct elemental_data *ed, int mode) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.change_mode_ack(ed, mode);
	}
	if( HPMHooks.count.HP_elemental_change_mode_ack_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed, int mode);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_change_mode_ack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed, mode);
		}
	}
	return retVal___;
}
int HP_elemental_change_mode(struct elemental_data *ed, uint32 mode) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_elemental_change_mode_pre ) {
		int (*preHookFunc) (struct elemental_data **ed, uint32 *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.change_mode(ed, mode);
	}
	if( HPMHooks.count.HP_elemental_change_mode_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed, uint32 mode);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_change_mode_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_change_mode_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed, mode);
		}
	}
	return retVal___;
}
void HP_elemental_heal(struct elemental_data *ed, int hp, int sp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_elemental_heal_pre ) {
		void (*preHookFunc) (struct elemental_data **ed, int *hp, int *sp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.elemental.heal(ed, hp, sp);
	}
	if( HPMHooks.count.HP_elemental_heal_post ) {
		void (*postHookFunc) (struct elemental_data *ed, int hp, int sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_heal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_heal_post[hIndex].func;
			postHookFunc(ed, hp, sp);
		}
	}
	return;
}
int HP_elemental_dead(struct elemental_data *ed) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.dead(ed);
	}
	if( HPMHooks.count.HP_elemental_dead_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_dead_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_dead_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed);
		}
	}
	return retVal___;
}
int HP_elemental_delete(struct elemental_data *ed, int reply) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.delete(ed, reply);
	}
	if( HPMHooks.count.HP_elemental_delete_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed, int reply);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed, reply);
		}
	}
	return retVal___;
}
void HP_elemental_summon_stop(struct elemental_data *ed) {
	int hIndex = 0;
	if( HPMHooks.count.HP_elemental_summon_stop_pre ) {
		void (*preHookFunc) (struct elemental_data **ed);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.elemental.summon_stop(ed);
	}
	if( HPMHooks.count.HP_elemental_summon_stop_post ) {
		void (*postHookFunc) (struct elemental_data *ed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_stop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_summon_stop_post[hIndex].func;
			postHookFunc(ed);
		}
	}
	return;
}
int HP_elemental_get_lifetime(struct elemental_data *ed) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.get_lifetime(ed);
	}
	if( HPMHooks.count.HP_elemental_get_lifetime_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_get_lifetime_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_get_lifetime_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed);
		}
	}
	return retVal___;
}
int HP_elemental_unlocktarget(struct elemental_data *ed) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.unlocktarget(ed);
	}
	if( HPMHooks.count.HP_elemental_unlocktarget_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_unlocktarget_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_unlocktarget_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed);
		}
	}
	return retVal___;
}
int HP_elemental_skillnotok(uint16 skill_id, struct elemental_data *ed) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.skillnotok(skill_id, ed);
	}
	if( HPMHooks.count.HP_elemental_skillnotok_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, struct elemental_data *ed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skillnotok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_skillnotok_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, ed);
		}
	}
	return retVal___;
}
int HP_elemental_set_target(struct map_session_data *sd, struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.set_target(sd, bl);
	}
	if( HPMHooks.count.HP_elemental_set_target_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_set_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_set_target_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, bl);
		}
	}
	return retVal___;
}
int HP_elemental_clean_single_effect(struct elemental_data *ed, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.clean_single_effect(ed, skill_id);
	}
	if( HPMHooks.count.HP_elemental_clean_single_effect_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_single_effect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_clean_single_effect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed, skill_id);
		}
	}
	return retVal___;
}
int HP_elemental_clean_effect(struct elemental_data *ed) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.clean_effect(ed);
	}
	if( HPMHooks.count.HP_elemental_clean_effect_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_clean_effect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_clean_effect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed);
		}
	}
	return retVal___;
}
int HP_elemental_action(struct elemental_data *ed, struct block_list *bl, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.action(ed, bl, tick);
	}
	if( HPMHooks.count.HP_elemental_action_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed, struct block_list *bl, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_action_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_action_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed, bl, tick);
		}
	}
	return retVal___;
}
struct skill_condition HP_elemental_skill_get_requirements(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	struct skill_condition retVal___ = { 0 };
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.skill_get_requirements(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_elemental_skill_get_requirements_post ) {
		struct skill_condition (*postHookFunc) (struct skill_condition retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_skill_get_requirements_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_skill_get_requirements_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_elemental_read_skilldb(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.read_skilldb();
	}
	if( HPMHooks.count.HP_elemental_read_skilldb_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_read_skilldb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_read_skilldb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_elemental_reload_db(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_elemental_reload_db_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.elemental.reload_db();
	}
	if( HPMHooks.count.HP_elemental_reload_db_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_reload_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_reload_db_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_elemental_reload_skilldb(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_elemental_reload_skilldb_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.elemental.reload_skilldb();
	}
	if( HPMHooks.count.HP_elemental_reload_skilldb_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_reload_skilldb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_reload_skilldb_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_elemental_search_index(int class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.search_index(class_);
	}
	if( HPMHooks.count.HP_elemental_search_index_post ) {
		int (*postHookFunc) (int retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_search_index_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_search_index_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
void HP_elemental_summon_init(struct elemental_data *ed) {
	int hIndex = 0;
	if( HPMHooks.count.HP_elemental_summon_init_pre ) {
		void (*preHookFunc) (struct elemental_data **ed);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.elemental.summon_init(ed);
	}
	if( HPMHooks.count.HP_elemental_summon_init_post ) {
		void (*postHookFunc) (struct elemental_data *ed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_summon_init_post[hIndex].func;
			postHookFunc(ed);
		}
	}
	return;
}
int HP_elemental_summon_end_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.summon_end_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_elemental_summon_end_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_summon_end_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_summon_end_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_elemental_ai_sub_timer_activesearch(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.elemental.ai_sub_timer_activesearch(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_activesearch_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_activesearch_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_elemental_ai_sub_timer(struct elemental_data *ed, struct map_session_data *sd, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.ai_sub_timer(ed, sd, tick);
	}
	if( HPMHooks.count.HP_elemental_ai_sub_timer_post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed, struct map_session_data *sd, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_ai_sub_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed, sd, tick);
		}
	}
	return retVal___;
}
int HP_elemental_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.elemental.ai_sub_foreachclient(sd, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_elemental_ai_sub_foreachclient_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_sub_foreachclient_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_elemental_ai_sub_foreachclient_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_elemental_ai_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.ai_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_elemental_ai_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_ai_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_ai_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_elemental_read_db(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.elemental.read_db();
	}
	if( HPMHooks.count.HP_elemental_read_db_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_elemental_read_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_elemental_read_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
/* grfio_interface */
void HP_grfio_init(const char *fname) {
	int hIndex = 0;
	if( HPMHooks.count.HP_grfio_init_pre ) {
		void (*preHookFunc) (const char **fname);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_grfio_init_pre[hIndex].func;
			preHookFunc(&fname);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.grfio.init(fname);
	}
	if( HPMHooks.count.HP_grfio_init_post ) {
		void (*postHookFunc) (const char *fname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_grfio_init_post[hIndex].func;
			postHookFunc(fname);
		}
	}
	return;
}
void HP_grfio_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_grfio_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_grfio_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.grfio.final();
	}
	if( HPMHooks.count.HP_grfio_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_grfio_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void* HP_grfio_reads(const char *fname, int *size) {
	int hIndex = 0;
	void* retVal___ = NULL;
	if( HPMHooks.count.HP_grfio_reads_pre ) {
		void* (*preHookFunc) (const char **fname, int **size);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_reads_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_grfio_reads_pre[hIndex].func;
			retVal___ = preHookFunc(&fname, &size);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.grfio.reads(fname, size);
	}
	if( HPMHooks.count.HP_grfio_reads_post ) {
		void* (*postHookFunc) (void* retVal___, const char *fname, int *size);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_reads_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_grfio_reads_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fname, size);
		}
	}
	return retVal___;
}
const char* HP_grfio_find_file(const char *fname) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_grfio_find_file_pre ) {
		const char* (*preHookFunc) (const char **fname);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_find_file_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_grfio_find_file_pre[hIndex].func;
			retVal___ = preHookFunc(&fname);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.grfio.find_file(fname);
	}
	if( HPMHooks.count.HP_grfio_find_file_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *fname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_find_file_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_grfio_find_file_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fname);
		}
	}
	return retVal___;
}
unsigned long HP_grfio_crc32(const unsigned char *buf, unsigned int len) {
	int hIndex = 0;
	unsigned long retVal___ = 0;
	if( HPMHooks.count.HP_grfio_crc32_pre ) {
		unsigned long (*preHookFunc) (const unsigned char **buf, unsigned int *len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_crc32_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_grfio_crc32_pre[hIndex].func;
			retVal___ = preHookFunc(&buf, &len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.grfio.crc32(buf, len);
	}
	if( HPMHooks.count.HP_grfio_crc32_post ) {
		unsigned long (*postHookFunc) (unsigned long retVal___, const unsigned char *buf, unsigned int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_crc32_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_grfio_crc32_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, buf, len);
		}
	}
	return retVal___;
}
int HP_grfio_decode_zip(void *dest, unsigned long *dest_len, const void *source, unsigned long source_len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_grfio_decode_zip_pre ) {
		int (*preHookFunc) (void **dest, unsigned long **dest_len, const void **source, unsigned long *source_len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_decode_zip_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_grfio_decode_zip_pre[hIndex].func;
			retVal___ = preHookFunc(&dest, &dest_len, &source, &source_len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.grfio.decode_zip(dest, dest_len, source, source_len);
	}
	if( HPMHooks.count.HP_grfio_decode_zip_post ) {
		int (*postHookFunc) (int retVal___, void *dest, unsigned long *dest_len, const void *source, unsigned long source_len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_decode_zip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_grfio_decode_zip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, dest, dest_len, source, source_len);
		}
	}
	return retVal___;
}
int HP_grfio_encode_zip(void *dest, unsigned long *dest_len, const void *source, unsigned long source_len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_grfio_encode_zip_pre ) {
		int (*preHookFunc) (void **dest, unsigned long **dest_len, const void **source, unsigned long *source_len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_encode_zip_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_grfio_encode_zip_pre[hIndex].func;
			retVal___ = preHookFunc(&dest, &dest_len, &source, &source_len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.grfio.encode_zip(dest, dest_len, source, source_len);
	}
	if( HPMHooks.count.HP_grfio_encode_zip_post ) {
		int (*postHookFunc) (int retVal___, void *dest, unsigned long *dest_len, const void *source, unsigned long source_len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_grfio_encode_zip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_grfio_encode_zip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, dest, dest_len, source, source_len);
		}
	}
	return retVal___;
}
/* guild_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.init(minimal);
	}
	if( HPMHooks.count.HP_guild_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.final();
	}
	if( HPMHooks.count.HP_guild_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_guild_skill_get_max(int id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.skill_get_max(id);
	}
	if( HPMHooks.count.HP_guild_skill_get_max_post ) {
		int (*postHookFunc) (int retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skill_get_max_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_skill_get_max_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
int HP_guild_checkskill(struct guild *g, int id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.checkskill(g, id);
	}
	if( HPMHooks.count.HP_guild_checkskill_post ) {
		int (*postHookFunc) (int retVal___, struct guild *g, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_checkskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g, id);
		}
	}
	return retVal___;
}
int HP_guild_check_skill_require(struct guild *g, int id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.check_skill_require(g, id);
	}
	if( HPMHooks.count.HP_guild_check_skill_require_post ) {
		int (*postHookFunc) (int retVal___, struct guild *g, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_skill_require_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_check_skill_require_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g, id);
		}
	}
	return retVal___;
}
int HP_guild_checkcastles(struct guild *g) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.checkcastles(g);
	}
	if( HPMHooks.count.HP_guild_checkcastles_post ) {
		int (*postHookFunc) (int retVal___, struct guild *g);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_checkcastles_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_checkcastles_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g);
		}
	}
	return retVal___;
}
bool HP_guild_isallied(int guild_id, int guild_id2) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.isallied(guild_id, guild_id2);
	}
	if( HPMHooks.count.HP_guild_isallied_post ) {
		bool (*postHookFunc) (bool retVal___, int guild_id, int guild_id2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_isallied_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_isallied_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, guild_id2);
		}
	}
	return retVal___;
}
struct guild* HP_guild_search(int guild_id) {
	int hIndex = 0;
	struct guild* retVal___ = NULL;
	if( HPMHooks.count.HP_guild_search_pre ) {
		struct guild* (*preHookFunc) (int *guild_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.search(guild_id);
	}
	if( HPMHooks.count.HP_guild_search_post ) {
		struct guild* (*postHookFunc) (struct guild* retVal___, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id);
		}
	}
	return retVal___;
}
struct guild* HP_guild_searchname(char *str) {
	int hIndex = 0;
	struct guild* retVal___ = NULL;
	if( HPMHooks.count.HP_guild_searchname_pre ) {
		struct guild* (*preHookFunc) (char **str);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.searchname(str);
	}
	if( HPMHooks.count.HP_guild_searchname_post ) {
		struct guild* (*postHookFunc) (struct guild* retVal___, char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_searchname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_searchname_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
struct guild_castle* HP_guild_castle_search(int gcid) {
	int hIndex = 0;
	struct guild_castle* retVal___ = NULL;
	if( HPMHooks.count.HP_guild_castle_search_pre ) {
		struct guild_castle* (*preHookFunc) (int *gcid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.castle_search(gcid);
	}
	if( HPMHooks.count.HP_guild_castle_search_post ) {
		struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, int gcid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_castle_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, gcid);
		}
	}
	return retVal___;
}
struct guild_castle* HP_guild_mapname2gc(const char *mapname) {
	int hIndex = 0;
	struct guild_castle* retVal___ = NULL;
	if( HPMHooks.count.HP_guild_mapname2gc_pre ) {
		struct guild_castle* (*preHookFunc) (const char **mapname);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.mapname2gc(mapname);
	}
	if( HPMHooks.count.HP_guild_mapname2gc_post ) {
		struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, const char *mapname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapname2gc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_mapname2gc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mapname);
		}
	}
	return retVal___;
}
struct guild_castle* HP_guild_mapindex2gc(short map_index) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.mapindex2gc(map_index);
	}
	if( HPMHooks.count.HP_guild_mapindex2gc_post ) {
		struct guild_castle* (*postHookFunc) (struct guild_castle* retVal___, short map_index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_mapindex2gc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_mapindex2gc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, map_index);
		}
	}
	return retVal___;
}
struct map_session_data* HP_guild_getavailablesd(struct guild *g) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_guild_getavailablesd_pre ) {
		struct map_session_data* (*preHookFunc) (struct guild **g);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.getavailablesd(g);
	}
	if( HPMHooks.count.HP_guild_getavailablesd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct guild *g);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getavailablesd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_getavailablesd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g);
		}
	}
	return retVal___;
}
int HP_guild_getindex(const struct guild *g, int account_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_getindex_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.getindex(g, account_id, char_id);
	}
	if( HPMHooks.count.HP_guild_getindex_post ) {
		int (*postHookFunc) (int retVal___, const struct guild *g, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getindex_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_getindex_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g, account_id, char_id);
		}
	}
	return retVal___;
}
int HP_guild_getposition(struct guild *g, struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.getposition(g, sd);
	}
	if( HPMHooks.count.HP_guild_getposition_post ) {
		int (*postHookFunc) (int retVal___, struct guild *g, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getposition_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_getposition_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g, sd);
		}
	}
	return retVal___;
}
unsigned int HP_guild_payexp(struct map_session_data *sd, unsigned int exp) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.payexp(sd, exp);
	}
	if( HPMHooks.count.HP_guild_payexp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, struct map_session_data *sd, unsigned int exp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_payexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, exp);
		}
	}
	return retVal___;
}
int HP_guild_getexp(struct map_session_data *sd, int exp) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.getexp(sd, exp);
	}
	if( HPMHooks.count.HP_guild_getexp_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int exp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_getexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_getexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, exp);
		}
	}
	return retVal___;
}
int HP_guild_create(struct map_session_data *sd, const char *name) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.create(sd, name);
	}
	if( HPMHooks.count.HP_guild_create_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name);
		}
	}
	return retVal___;
}
int HP_guild_created(int account_id, int guild_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.created(account_id, guild_id);
	}
	if( HPMHooks.count.HP_guild_created_post ) {
		int (*postHookFunc) (int retVal___, int account_id, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_created_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_created_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, guild_id);
		}
	}
	return retVal___;
}
int HP_guild_request_info(int guild_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.request_info(guild_id);
	}
	if( HPMHooks.count.HP_guild_request_info_post ) {
		int (*postHookFunc) (int retVal___, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_request_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_request_info_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id);
		}
	}
	return retVal___;
}
int HP_guild_recv_noinfo(int guild_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.recv_noinfo(guild_id);
	}
	if( HPMHooks.count.HP_guild_recv_noinfo_post ) {
		int (*postHookFunc) (int retVal___, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_noinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_recv_noinfo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id);
		}
	}
	return retVal___;
}
int HP_guild_recv_info(const struct guild *sg) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_recv_info_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.recv_info(sg);
	}
	if( HPMHooks.count.HP_guild_recv_info_post ) {
		int (*postHookFunc) (int retVal___, const struct guild *sg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_recv_info_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sg);
		}
	}
	return retVal___;
}
int HP_guild_npc_request_info(int guild_id, const char *ev) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.npc_request_info(guild_id, ev);
	}
	if( HPMHooks.count.HP_guild_npc_request_info_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, const char *ev);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_npc_request_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_npc_request_info_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, ev);
		}
	}
	return retVal___;
}
int HP_guild_invite(struct map_session_data *sd, struct map_session_data *tsd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.invite(sd, tsd);
	}
	if( HPMHooks.count.HP_guild_invite_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_invite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_invite_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, tsd);
		}
	}
	return retVal___;
}
int HP_guild_reply_invite(struct map_session_data *sd, int guild_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.reply_invite(sd, guild_id, flag);
	}
	if( HPMHooks.count.HP_guild_reply_invite_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_invite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_reply_invite_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, guild_id, flag);
		}
	}
	return retVal___;
}
void HP_guild_member_joined(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_member_joined_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.member_joined(sd);
	}
	if( HPMHooks.count.HP_guild_member_joined_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_joined_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_member_joined_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_guild_member_added(int guild_id, int account_id, int char_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.member_added(guild_id, account_id, char_id, flag);
	}
	if( HPMHooks.count.HP_guild_member_added_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_added_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_member_added_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, flag);
		}
	}
	return retVal___;
}
int HP_guild_leave(struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.leave(sd, guild_id, account_id, char_id, mes);
	}
	if( HPMHooks.count.HP_guild_leave_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_leave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, guild_id, account_id, char_id, mes);
		}
	}
	return retVal___;
}
int HP_guild_member_withdraw(int guild_id, int account_id, int char_id, int flag, const char *name, const char *mes) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.member_withdraw(guild_id, account_id, char_id, flag, name, mes);
	}
	if( HPMHooks.count.HP_guild_member_withdraw_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int flag, const char *name, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_member_withdraw_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_member_withdraw_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, flag, name, mes);
		}
	}
	return retVal___;
}
int HP_guild_expulsion(struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.expulsion(sd, guild_id, account_id, char_id, mes);
	}
	if( HPMHooks.count.HP_guild_expulsion_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, int account_id, int char_id, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expulsion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_expulsion_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, guild_id, account_id, char_id, mes);
		}
	}
	return retVal___;
}
int HP_guild_skillup(struct map_session_data *sd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.skillup(sd, skill_id);
	}
	if( HPMHooks.count.HP_guild_skillup_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_skillup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
void HP_guild_block_skill(struct map_session_data *sd, int time) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_block_skill_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *time);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.block_skill(sd, time);
	}
	if( HPMHooks.count.HP_guild_block_skill_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int time);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_block_skill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_block_skill_post[hIndex].func;
			postHookFunc(sd, time);
		}
	}
	return;
}
int HP_guild_reqalliance(struct map_session_data *sd, struct map_session_data *tsd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.reqalliance(sd, tsd);
	}
	if( HPMHooks.count.HP_guild_reqalliance_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reqalliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_reqalliance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, tsd);
		}
	}
	return retVal___;
}
int HP_guild_reply_reqalliance(struct map_session_data *sd, int account_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.reply_reqalliance(sd, account_id, flag);
	}
	if( HPMHooks.count.HP_guild_reply_reqalliance_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int account_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_reply_reqalliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_reply_reqalliance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, account_id, flag);
		}
	}
	return retVal___;
}
int HP_guild_allianceack(int guild_id1, int guild_id2, int account_id1, int account_id2, int flag, const char *name1, const char *name2) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.allianceack(guild_id1, guild_id2, account_id1, account_id2, flag, name1, name2);
	}
	if( HPMHooks.count.HP_guild_allianceack_post ) {
		int (*postHookFunc) (int retVal___, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag, const char *name1, const char *name2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_allianceack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_allianceack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id1, guild_id2, account_id1, account_id2, flag, name1, name2);
		}
	}
	return retVal___;
}
int HP_guild_delalliance(struct map_session_data *sd, int guild_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.delalliance(sd, guild_id, flag);
	}
	if( HPMHooks.count.HP_guild_delalliance_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_delalliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_delalliance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, guild_id, flag);
		}
	}
	return retVal___;
}
int HP_guild_opposition(struct map_session_data *sd, struct map_session_data *tsd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.opposition(sd, tsd);
	}
	if( HPMHooks.count.HP_guild_opposition_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_opposition_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_opposition_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, tsd);
		}
	}
	return retVal___;
}
int HP_guild_check_alliance(int guild_id1, int guild_id2, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.check_alliance(guild_id1, guild_id2, flag);
	}
	if( HPMHooks.count.HP_guild_check_alliance_post ) {
		int (*postHookFunc) (int retVal___, int guild_id1, int guild_id2, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_alliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_check_alliance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id1, guild_id2, flag);
		}
	}
	return retVal___;
}
int HP_guild_send_memberinfoshort(struct map_session_data *sd, int online) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.send_memberinfoshort(sd, online);
	}
	if( HPMHooks.count.HP_guild_send_memberinfoshort_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int online);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_memberinfoshort_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_send_memberinfoshort_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, online);
		}
	}
	return retVal___;
}
int HP_guild_recv_memberinfoshort(int guild_id, int account_id, int char_id, int online, int lv, int class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.recv_memberinfoshort(guild_id, account_id, char_id, online, lv, class_);
	}
	if( HPMHooks.count.HP_guild_recv_memberinfoshort_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int online, int lv, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_memberinfoshort_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_recv_memberinfoshort_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, online, lv, class_);
		}
	}
	return retVal___;
}
int HP_guild_change_memberposition(int guild_id, int account_id, int char_id, short idx) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.change_memberposition(guild_id, account_id, char_id, idx);
	}
	if( HPMHooks.count.HP_guild_change_memberposition_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, short idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_memberposition_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_change_memberposition_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, idx);
		}
	}
	return retVal___;
}
int HP_guild_memberposition_changed(struct guild *g, int idx, int pos) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.memberposition_changed(g, idx, pos);
	}
	if( HPMHooks.count.HP_guild_memberposition_changed_post ) {
		int (*postHookFunc) (int retVal___, struct guild *g, int idx, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_memberposition_changed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_memberposition_changed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g, idx, pos);
		}
	}
	return retVal___;
}
int HP_guild_change_position(int guild_id, int idx, int mode, int exp_mode, const char *name) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.change_position(guild_id, idx, mode, exp_mode, name);
	}
	if( HPMHooks.count.HP_guild_change_position_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int idx, int mode, int exp_mode, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_position_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_change_position_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, idx, mode, exp_mode, name);
		}
	}
	return retVal___;
}
int HP_guild_position_changed(int guild_id, int idx, const struct guild_position *p) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_position_changed_pre ) {
		int (*preHookFunc) (int *guild_id, int *idx, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.position_changed(guild_id, idx, p);
	}
	if( HPMHooks.count.HP_guild_position_changed_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int idx, const struct guild_position *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_position_changed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_position_changed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, idx, p);
		}
	}
	return retVal___;
}
int HP_guild_change_notice(struct map_session_data *sd, int guild_id, const char *mes1, const char *mes2) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.change_notice(sd, guild_id, mes1, mes2);
	}
	if( HPMHooks.count.HP_guild_change_notice_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int guild_id, const char *mes1, const char *mes2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_notice_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_change_notice_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, guild_id, mes1, mes2);
		}
	}
	return retVal___;
}
int HP_guild_notice_changed(int guild_id, const char *mes1, const char *mes2) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.notice_changed(guild_id, mes1, mes2);
	}
	if( HPMHooks.count.HP_guild_notice_changed_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, const char *mes1, const char *mes2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_notice_changed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_notice_changed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, mes1, mes2);
		}
	}
	return retVal___;
}
int HP_guild_change_emblem(struct map_session_data *sd, int len, const char *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.change_emblem(sd, len, data);
	}
	if( HPMHooks.count.HP_guild_change_emblem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int len, const char *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_change_emblem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_change_emblem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, len, data);
		}
	}
	return retVal___;
}
int HP_guild_emblem_changed(int len, int guild_id, int emblem_id, const char *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.emblem_changed(len, guild_id, emblem_id, data);
	}
	if( HPMHooks.count.HP_guild_emblem_changed_post ) {
		int (*postHookFunc) (int retVal___, int len, int guild_id, int emblem_id, const char *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_emblem_changed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_emblem_changed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, len, guild_id, emblem_id, data);
		}
	}
	return retVal___;
}
int HP_guild_send_message(struct map_session_data *sd, const char *mes) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_send_message_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.send_message(sd, mes);
	}
	if( HPMHooks.count.HP_guild_send_message_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_send_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, mes);
		}
	}
	return retVal___;
}
int HP_guild_recv_message(int guild_id, int account_id, const char *mes, int len) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.recv_message(guild_id, account_id, mes, len);
	}
	if( HPMHooks.count.HP_guild_recv_message_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, const char *mes, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_recv_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_recv_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, mes, len);
		}
	}
	return retVal___;
}
int HP_guild_send_dot_remove(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.send_dot_remove(sd);
	}
	if( HPMHooks.count.HP_guild_send_dot_remove_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_dot_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_send_dot_remove_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_guild_skillupack(int guild_id, uint16 skill_id, int account_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.skillupack(guild_id, skill_id, account_id);
	}
	if( HPMHooks.count.HP_guild_skillupack_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, uint16 skill_id, int account_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_skillupack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_skillupack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, skill_id, account_id);
		}
	}
	return retVal___;
}
int HP_guild_dobreak(struct map_session_data *sd, const char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_dobreak_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.dobreak(sd, name);
	}
	if( HPMHooks.count.HP_guild_dobreak_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_dobreak_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_dobreak_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name);
		}
	}
	return retVal___;
}
int HP_guild_broken(int guild_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.broken(guild_id, flag);
	}
	if( HPMHooks.count.HP_guild_broken_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_broken_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, flag);
		}
	}
	return retVal___;
}
int HP_guild_gm_change(int guild_id, struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.gm_change(guild_id, sd);
	}
	if( HPMHooks.count.HP_guild_gm_change_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_change_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_gm_change_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, sd);
		}
	}
	return retVal___;
}
int HP_guild_gm_changed(int guild_id, int account_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.gm_changed(guild_id, account_id, char_id);
	}
	if( HPMHooks.count.HP_guild_gm_changed_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_gm_changed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_gm_changed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id);
		}
	}
	return retVal___;
}
void HP_guild_castle_map_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_castle_map_init_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.castle_map_init();
	}
	if( HPMHooks.count.HP_guild_castle_map_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_map_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_castle_map_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_guild_castledatasave(int castle_id, int index, int value) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.castledatasave(castle_id, index, value);
	}
	if( HPMHooks.count.HP_guild_castledatasave_post ) {
		int (*postHookFunc) (int retVal___, int castle_id, int index, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledatasave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_castledatasave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, castle_id, index, value);
		}
	}
	return retVal___;
}
int HP_guild_castledataloadack(int len, const struct guild_castle *gc) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_castledataloadack_pre ) {
		int (*preHookFunc) (int *len, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.castledataloadack(len, gc);
	}
	if( HPMHooks.count.HP_guild_castledataloadack_post ) {
		int (*postHookFunc) (int retVal___, int len, const struct guild_castle *gc);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castledataloadack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_castledataloadack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, len, gc);
		}
	}
	return retVal___;
}
void HP_guild_castle_reconnect(int castle_id, int index, int value) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_castle_reconnect_pre ) {
		void (*preHookFunc) (int *castle_id, int *index, int *value);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.castle_reconnect(castle_id, index, value);
	}
	if( HPMHooks.count.HP_guild_castle_reconnect_post ) {
		void (*postHookFunc) (int castle_id, int index, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_reconnect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_castle_reconnect_post[hIndex].func;
			postHookFunc(castle_id, index, value);
		}
	}
	return;
}
void HP_guild_agit_start(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_agit_start_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.agit_start();
	}
	if( HPMHooks.count.HP_guild_agit_start_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_agit_start_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_guild_agit_end(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_agit_end_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.agit_end();
	}
	if( HPMHooks.count.HP_guild_agit_end_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_agit_end_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_guild_agit2_start(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_agit2_start_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.agit2_start();
	}
	if( HPMHooks.count.HP_guild_agit2_start_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit2_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_agit2_start_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_guild_agit2_end(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_agit2_end_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.agit2_end();
	}
	if( HPMHooks.count.HP_guild_agit2_end_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_agit2_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_agit2_end_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_guild_flag_add(struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_flag_add_pre ) {
		void (*preHookFunc) (struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.flag_add(nd);
	}
	if( HPMHooks.count.HP_guild_flag_add_post ) {
		void (*postHookFunc) (struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_flag_add_post[hIndex].func;
			postHookFunc(nd);
		}
	}
	return;
}
void HP_guild_flag_remove(struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_flag_remove_pre ) {
		void (*preHookFunc) (struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.flag_remove(nd);
	}
	if( HPMHooks.count.HP_guild_flag_remove_post ) {
		void (*postHookFunc) (struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flag_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_flag_remove_post[hIndex].func;
			postHookFunc(nd);
		}
	}
	return;
}
void HP_guild_flags_clear(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_flags_clear_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.flags_clear();
	}
	if( HPMHooks.count.HP_guild_flags_clear_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_flags_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_flags_clear_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_guild_aura_refresh(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_aura_refresh_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.aura_refresh(sd, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_guild_aura_refresh_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_aura_refresh_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_aura_refresh_post[hIndex].func;
			postHookFunc(sd, skill_id, skill_lv);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.retrieveitembound(char_id, aid, guild_id);
	}
	if( HPMHooks.count.HP_guild_retrieveitembound_post ) {
		void (*postHookFunc) (int char_id, int aid, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_retrieveitembound_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_retrieveitembound_post[hIndex].func;
			postHookFunc(char_id, aid, guild_id);
		}
	}
	return;
}
int HP_guild_payexp_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.payexp_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_guild_payexp_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_payexp_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
struct map_session_data* HP_guild_sd_check(int guild_id, int account_id, int char_id) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_guild_sd_check_pre ) {
		struct map_session_data* (*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.sd_check(guild_id, account_id, char_id);
	}
	if( HPMHooks.count.HP_guild_sd_check_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int guild_id, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_sd_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_sd_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id);
		}
	}
	return retVal___;
}
bool HP_guild_read_guildskill_tree_db(char *split[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.read_guildskill_tree_db(split, columns, current);
	}
	if( HPMHooks.count.HP_guild_read_guildskill_tree_db_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_guildskill_tree_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_read_guildskill_tree_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, columns, current);
		}
	}
	return retVal___;
}
bool HP_guild_read_castledb(char *str[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.read_castledb(str, columns, current);
	}
	if( HPMHooks.count.HP_guild_read_castledb_post ) {
		bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_read_castledb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_read_castledb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, columns, current);
		}
	}
	return retVal___;
}
int HP_guild_payexp_timer_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_payexp_timer_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.guild.payexp_timer_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_guild_payexp_timer_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_payexp_timer_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_guild_payexp_timer_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_guild_send_xy_timer_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_send_xy_timer_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.guild.send_xy_timer_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_guild_send_xy_timer_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_guild_send_xy_timer_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_guild_send_xy_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.send_xy_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_guild_send_xy_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_send_xy_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_send_xy_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
struct DBData HP_guild_create_expcache(union DBKey key, va_list args) {
	int hIndex = 0;
	struct DBData retVal___ = { 0 };
	if( HPMHooks.count.HP_guild_create_expcache_pre ) {
		struct DBData (*preHookFunc) (union 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;
			retVal___ = preHookFunc(&key, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.guild.create_expcache(key, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_guild_create_expcache_post ) {
		struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_create_expcache_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_guild_create_expcache_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_guild_eventlist_db_final(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_eventlist_db_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.guild.eventlist_db_final(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_guild_eventlist_db_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_eventlist_db_final_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_guild_eventlist_db_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_guild_expcache_db_final(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_expcache_db_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.guild.expcache_db_final(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_guild_expcache_db_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_expcache_db_final_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_guild_expcache_db_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_guild_castle_db_final(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_castle_db_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.guild.castle_db_final(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_guild_castle_db_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_db_final_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_guild_castle_db_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_guild_broken_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_broken_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.guild.broken_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_guild_broken_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_broken_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_guild_broken_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_guild_castle_broken_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_castle_broken_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.guild.castle_broken_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_guild_castle_broken_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_broken_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_guild_castle_broken_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_guild_makemember(struct guild_member *m, struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_makemember_pre ) {
		void (*preHookFunc) (struct guild_member **m, struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.guild.makemember(m, sd);
	}
	if( HPMHooks.count.HP_guild_makemember_post ) {
		void (*postHookFunc) (struct guild_member *m, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_makemember_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_makemember_post[hIndex].func;
			postHookFunc(m, sd);
		}
	}
	return;
}
int HP_guild_check_member(const struct guild *g) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_guild_check_member_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.check_member(g);
	}
	if( HPMHooks.count.HP_guild_check_member_post ) {
		int (*postHookFunc) (int retVal___, const struct guild *g);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_check_member_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_check_member_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g);
		}
	}
	return retVal___;
}
int HP_guild_get_alliance_count(struct guild *g, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.guild.get_alliance_count(g, flag);
	}
	if( HPMHooks.count.HP_guild_get_alliance_count_post ) {
		int (*postHookFunc) (int retVal___, struct guild *g, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_get_alliance_count_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_guild_get_alliance_count_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, g, flag);
		}
	}
	return retVal___;
}
void HP_guild_castle_reconnect_sub(void *key, void *data, va_list ap) {
	int hIndex = 0;
	if( HPMHooks.count.HP_guild_castle_reconnect_sub_pre ) {
		void (*preHookFunc) (void **key, void **data, va_list ap);
		*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;
			preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		HPMHooks.source.guild.castle_reconnect_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_guild_castle_reconnect_sub_post ) {
		void (*postHookFunc) (void *key, void *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_guild_castle_reconnect_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_guild_castle_reconnect_sub_post[hIndex].func;
			postHookFunc(key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return;
}
/* guild_storage_interface */
struct guild_storage* HP_gstorage_ensure(int guild_id) {
	int hIndex = 0;
	struct guild_storage* retVal___ = NULL;
	if( HPMHooks.count.HP_gstorage_ensure_pre ) {
		struct guild_storage* (*preHookFunc) (int *guild_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_ensure_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_gstorage_ensure_pre[hIndex].func;
			retVal___ = preHookFunc(&guild_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.ensure(guild_id);
	}
	if( HPMHooks.count.HP_gstorage_ensure_post ) {
		struct guild_storage* (*postHookFunc) (struct guild_storage* retVal___, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_ensure_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_ensure_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.gstorage.init(minimal);
	}
	if( HPMHooks.count.HP_gstorage_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.gstorage.final();
	}
	if( HPMHooks.count.HP_gstorage_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_gstorage_delete(int guild_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.delete(guild_id);
	}
	if( HPMHooks.count.HP_gstorage_delete_post ) {
		int (*postHookFunc) (int retVal___, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id);
		}
	}
	return retVal___;
}
int HP_gstorage_open(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.open(sd);
	}
	if( HPMHooks.count.HP_gstorage_open_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_open_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_gstorage_additem(struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.additem(sd, stor, item_data, amount);
	}
	if( HPMHooks.count.HP_gstorage_additem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, struct item *item_data, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_additem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_additem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, stor, item_data, amount);
		}
	}
	return retVal___;
}
int HP_gstorage_delitem(struct map_session_data *sd, struct guild_storage *stor, int n, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.delitem(sd, stor, n, amount);
	}
	if( HPMHooks.count.HP_gstorage_delitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct guild_storage *stor, int n, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_delitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_delitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, stor, n, amount);
		}
	}
	return retVal___;
}
int HP_gstorage_add(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.add(sd, index, amount);
	}
	if( HPMHooks.count.HP_gstorage_add_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_add_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index, amount);
		}
	}
	return retVal___;
}
int HP_gstorage_get(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.get(sd, index, amount);
	}
	if( HPMHooks.count.HP_gstorage_get_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_get_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_get_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index, amount);
		}
	}
	return retVal___;
}
int HP_gstorage_addfromcart(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.addfromcart(sd, index, amount);
	}
	if( HPMHooks.count.HP_gstorage_addfromcart_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_addfromcart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_addfromcart_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index, amount);
		}
	}
	return retVal___;
}
int HP_gstorage_gettocart(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.gettocart(sd, index, amount);
	}
	if( HPMHooks.count.HP_gstorage_gettocart_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_gettocart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_gettocart_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index, amount);
		}
	}
	return retVal___;
}
int HP_gstorage_close(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.close(sd);
	}
	if( HPMHooks.count.HP_gstorage_close_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_close_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_gstorage_pc_quit(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.pc_quit(sd, flag);
	}
	if( HPMHooks.count.HP_gstorage_pc_quit_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_pc_quit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_pc_quit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, flag);
		}
	}
	return retVal___;
}
int HP_gstorage_save(int account_id, int guild_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.save(account_id, guild_id, flag);
	}
	if( HPMHooks.count.HP_gstorage_save_post ) {
		int (*postHookFunc) (int retVal___, int account_id, int guild_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_save_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, guild_id, flag);
		}
	}
	return retVal___;
}
int HP_gstorage_saved(int guild_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.gstorage.saved(guild_id);
	}
	if( HPMHooks.count.HP_gstorage_saved_post ) {
		int (*postHookFunc) (int retVal___, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_saved_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_gstorage_saved_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id);
		}
	}
	return retVal___;
}
struct DBData HP_gstorage_create(union DBKey key, va_list args) {
	int hIndex = 0;
	struct DBData retVal___ = { 0 };
	if( HPMHooks.count.HP_gstorage_create_pre ) {
		struct DBData (*preHookFunc) (union 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;
			retVal___ = preHookFunc(&key, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.gstorage.create(key, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_gstorage_create_post ) {
		struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_gstorage_create_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_gstorage_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
/* homunculus_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.init(minimal);
	}
	if( HPMHooks.count.HP_homun_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.final();
	}
	if( HPMHooks.count.HP_homun_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_homun_reload(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_reload_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_homun_reload_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.reload();
	}
	if( HPMHooks.count.HP_homun_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_homun_reload_skill(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_reload_skill_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.reload_skill();
	}
	if( HPMHooks.count.HP_homun_reload_skill_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_reload_skill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_reload_skill_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct view_data* HP_homun_get_viewdata(int class_) {
	int hIndex = 0;
	struct view_data* retVal___ = NULL;
	if( HPMHooks.count.HP_homun_get_viewdata_pre ) {
		struct view_data* (*preHookFunc) (int *class_);
		*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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.get_viewdata(class_);
	}
	if( HPMHooks.count.HP_homun_get_viewdata_post ) {
		struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_get_viewdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_get_viewdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
enum homun_type HP_homun_class2type(int class_) {
	int hIndex = 0;
	enum homun_type retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.class2type(class_);
	}
	if( HPMHooks.count.HP_homun_class2type_post ) {
		enum homun_type (*postHookFunc) (enum homun_type retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_class2type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_class2type_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
void HP_homun_damaged(struct homun_data *hd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_damaged_pre ) {
		void (*preHookFunc) (struct homun_data **hd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.damaged(hd);
	}
	if( HPMHooks.count.HP_homun_damaged_post ) {
		void (*postHookFunc) (struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_damaged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_damaged_post[hIndex].func;
			postHookFunc(hd);
		}
	}
	return;
}
int HP_homun_dead(struct homun_data *hd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.dead(hd);
	}
	if( HPMHooks.count.HP_homun_dead_post ) {
		int (*postHookFunc) (int retVal___, struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_dead_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_dead_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd);
		}
	}
	return retVal___;
}
int HP_homun_vaporize(struct map_session_data *sd, enum homun_state flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.vaporize(sd, flag);
	}
	if( HPMHooks.count.HP_homun_vaporize_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum homun_state flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_vaporize_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_vaporize_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, flag);
		}
	}
	return retVal___;
}
int HP_homun_delete(struct homun_data *hd, int emote) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.delete(hd, emote);
	}
	if( HPMHooks.count.HP_homun_delete_post ) {
		int (*postHookFunc) (int retVal___, struct homun_data *hd, int emote);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, emote);
		}
	}
	return retVal___;
}
int HP_homun_checkskill(struct homun_data *hd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.checkskill(hd, skill_id);
	}
	if( HPMHooks.count.HP_homun_checkskill_post ) {
		int (*postHookFunc) (int retVal___, struct homun_data *hd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_checkskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_checkskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, skill_id);
		}
	}
	return retVal___;
}
int HP_homun_calc_skilltree(struct homun_data *hd, int flag_evolve) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.calc_skilltree(hd, flag_evolve);
	}
	if( HPMHooks.count.HP_homun_calc_skilltree_post ) {
		int (*postHookFunc) (int retVal___, struct homun_data *hd, int flag_evolve);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_calc_skilltree_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_calc_skilltree_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, flag_evolve);
		}
	}
	return retVal___;
}
int HP_homun_skill_tree_get_max(int id, int b_class) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.skill_tree_get_max(id, b_class);
	}
	if( HPMHooks.count.HP_homun_skill_tree_get_max_post ) {
		int (*postHookFunc) (int retVal___, int id, int b_class);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skill_tree_get_max_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_skill_tree_get_max_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id, b_class);
		}
	}
	return retVal___;
}
void HP_homun_skillup(struct homun_data *hd, uint16 skill_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_skillup_pre ) {
		void (*preHookFunc) (struct homun_data **hd, uint16 *skill_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.skillup(hd, skill_id);
	}
	if( HPMHooks.count.HP_homun_skillup_post ) {
		void (*postHookFunc) (struct homun_data *hd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skillup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_skillup_post[hIndex].func;
			postHookFunc(hd, skill_id);
		}
	}
	return;
}
bool HP_homun_levelup(struct homun_data *hd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.levelup(hd);
	}
	if( HPMHooks.count.HP_homun_levelup_post ) {
		bool (*postHookFunc) (bool retVal___, struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_levelup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_levelup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd);
		}
	}
	return retVal___;
}
int HP_homun_change_class(struct homun_data *hd, short class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.change_class(hd, class_);
	}
	if( HPMHooks.count.HP_homun_change_class_post ) {
		int (*postHookFunc) (int retVal___, struct homun_data *hd, short class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_class_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_change_class_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, class_);
		}
	}
	return retVal___;
}
bool HP_homun_evolve(struct homun_data *hd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.evolve(hd);
	}
	if( HPMHooks.count.HP_homun_evolve_post ) {
		bool (*postHookFunc) (bool retVal___, struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_evolve_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_evolve_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd);
		}
	}
	return retVal___;
}
bool HP_homun_mutate(struct homun_data *hd, int homun_id) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.mutate(hd, homun_id);
	}
	if( HPMHooks.count.HP_homun_mutate_post ) {
		bool (*postHookFunc) (bool retVal___, struct homun_data *hd, int homun_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_mutate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_mutate_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, homun_id);
		}
	}
	return retVal___;
}
int HP_homun_gainexp(struct homun_data *hd, unsigned int exp) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.gainexp(hd, exp);
	}
	if( HPMHooks.count.HP_homun_gainexp_post ) {
		int (*postHookFunc) (int retVal___, struct homun_data *hd, unsigned int exp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_gainexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_gainexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, exp);
		}
	}
	return retVal___;
}
unsigned int HP_homun_add_intimacy(struct homun_data *hd, unsigned int value) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.add_intimacy(hd, value);
	}
	if( HPMHooks.count.HP_homun_add_intimacy_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, struct homun_data *hd, unsigned int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_add_intimacy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_add_intimacy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, value);
		}
	}
	return retVal___;
}
unsigned int HP_homun_consume_intimacy(struct homun_data *hd, unsigned int value) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.consume_intimacy(hd, value);
	}
	if( HPMHooks.count.HP_homun_consume_intimacy_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, struct homun_data *hd, unsigned int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_consume_intimacy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_consume_intimacy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, value);
		}
	}
	return retVal___;
}
void HP_homun_healed(struct homun_data *hd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_healed_pre ) {
		void (*preHookFunc) (struct homun_data **hd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.healed(hd);
	}
	if( HPMHooks.count.HP_homun_healed_post ) {
		void (*postHookFunc) (struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_healed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_healed_post[hIndex].func;
			postHookFunc(hd);
		}
	}
	return;
}
void HP_homun_save(struct homun_data *hd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_save_pre ) {
		void (*preHookFunc) (struct homun_data **hd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.save(hd);
	}
	if( HPMHooks.count.HP_homun_save_post ) {
		void (*postHookFunc) (struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_save_post[hIndex].func;
			postHookFunc(hd);
		}
	}
	return;
}
unsigned char HP_homun_menu(struct map_session_data *sd, unsigned char menu_num) {
	int hIndex = 0;
	unsigned char retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.menu(sd, menu_num);
	}
	if( HPMHooks.count.HP_homun_menu_post ) {
		unsigned char (*postHookFunc) (unsigned char retVal___, struct map_session_data *sd, unsigned char menu_num);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_menu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_menu_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, menu_num);
		}
	}
	return retVal___;
}
bool HP_homun_feed(struct map_session_data *sd, struct homun_data *hd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.feed(sd, hd);
	}
	if( HPMHooks.count.HP_homun_feed_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_feed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_feed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, hd);
		}
	}
	return retVal___;
}
int HP_homun_hunger_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.hunger_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_homun_hunger_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_hunger_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_hunger_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_homun_hunger_timer_delete(struct homun_data *hd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_hunger_timer_delete_pre ) {
		void (*preHookFunc) (struct homun_data **hd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.hunger_timer_delete(hd);
	}
	if( HPMHooks.count.HP_homun_hunger_timer_delete_post ) {
		void (*postHookFunc) (struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_hunger_timer_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_hunger_timer_delete_post[hIndex].func;
			postHookFunc(hd);
		}
	}
	return;
}
int HP_homun_change_name(struct map_session_data *sd, const char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_homun_change_name_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.change_name(sd, name);
	}
	if( HPMHooks.count.HP_homun_change_name_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_change_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name);
		}
	}
	return retVal___;
}
bool HP_homun_change_name_ack(struct map_session_data *sd, const char *name, int flag) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_homun_change_name_ack_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.change_name_ack(sd, name, flag);
	}
	if( HPMHooks.count.HP_homun_change_name_ack_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *name, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_change_name_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_change_name_ack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name, flag);
		}
	}
	return retVal___;
}
int HP_homun_db_search(int key, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.db_search(key, type);
	}
	if( HPMHooks.count.HP_homun_db_search_post ) {
		int (*postHookFunc) (int retVal___, int key, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_db_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_db_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, type);
		}
	}
	return retVal___;
}
bool HP_homun_create(struct map_session_data *sd, const struct s_homunculus *hom) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_homun_create_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.create(sd, hom);
	}
	if( HPMHooks.count.HP_homun_create_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const struct s_homunculus *hom);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, hom);
		}
	}
	return retVal___;
}
void HP_homun_init_timers(struct homun_data *hd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_init_timers_pre ) {
		void (*preHookFunc) (struct homun_data **hd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.init_timers(hd);
	}
	if( HPMHooks.count.HP_homun_init_timers_post ) {
		void (*postHookFunc) (struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_init_timers_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_init_timers_post[hIndex].func;
			postHookFunc(hd);
		}
	}
	return;
}
bool HP_homun_call(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.call(sd);
	}
	if( HPMHooks.count.HP_homun_call_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_call_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_call_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
bool HP_homun_recv_data(int account_id, const struct s_homunculus *sh, int flag) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_homun_recv_data_pre ) {
		bool (*preHookFunc) (int *account_id, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.recv_data(account_id, sh, flag);
	}
	if( HPMHooks.count.HP_homun_recv_data_post ) {
		bool (*postHookFunc) (bool retVal___, int account_id, const struct s_homunculus *sh, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_recv_data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_recv_data_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, sh, flag);
		}
	}
	return retVal___;
}
bool HP_homun_creation_request(struct map_session_data *sd, int class_) {
	int hIndex = 0;
	bool retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.creation_request(sd, class_);
	}
	if( HPMHooks.count.HP_homun_creation_request_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_creation_request_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_creation_request_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, class_);
		}
	}
	return retVal___;
}
bool HP_homun_ressurect(struct map_session_data *sd, unsigned char per, short x, short y) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.ressurect(sd, per, x, y);
	}
	if( HPMHooks.count.HP_homun_ressurect_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned char per, short x, short y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_ressurect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_ressurect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, per, x, y);
		}
	}
	return retVal___;
}
void HP_homun_revive(struct homun_data *hd, unsigned int hp, unsigned int sp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_revive_pre ) {
		void (*preHookFunc) (struct homun_data **hd, unsigned int *hp, unsigned int *sp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.revive(hd, hp, sp);
	}
	if( HPMHooks.count.HP_homun_revive_post ) {
		void (*postHookFunc) (struct homun_data *hd, unsigned int hp, unsigned int sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_revive_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_revive_post[hIndex].func;
			postHookFunc(hd, hp, sp);
		}
	}
	return;
}
void HP_homun_stat_reset(struct homun_data *hd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_stat_reset_pre ) {
		void (*preHookFunc) (struct homun_data **hd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.stat_reset(hd);
	}
	if( HPMHooks.count.HP_homun_stat_reset_post ) {
		void (*postHookFunc) (struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_stat_reset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_stat_reset_post[hIndex].func;
			postHookFunc(hd);
		}
	}
	return;
}
bool HP_homun_shuffle(struct homun_data *hd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.shuffle(hd);
	}
	if( HPMHooks.count.HP_homun_shuffle_post ) {
		bool (*postHookFunc) (bool retVal___, struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_shuffle_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_shuffle_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd);
		}
	}
	return retVal___;
}
bool HP_homun_read_db_sub(char *str[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.read_db_sub(str, columns, current);
	}
	if( HPMHooks.count.HP_homun_read_db_sub_post ) {
		bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_read_db_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, columns, current);
		}
	}
	return retVal___;
}
void HP_homun_read_db(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_read_db_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.read_db();
	}
	if( HPMHooks.count.HP_homun_read_db_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_read_db_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_homun_read_skill_db_sub(char *split[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.read_skill_db_sub(split, columns, current);
	}
	if( HPMHooks.count.HP_homun_read_skill_db_sub_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_read_skill_db_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_read_skill_db_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, columns, current);
		}
	}
	return retVal___;
}
void HP_homun_skill_db_read(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_skill_db_read_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.skill_db_read();
	}
	if( HPMHooks.count.HP_homun_skill_db_read_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_skill_db_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_skill_db_read_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_homun_exp_db_read(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_exp_db_read_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.exp_db_read();
	}
	if( HPMHooks.count.HP_homun_exp_db_read_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_exp_db_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_exp_db_read_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_homun_addspiritball(struct homun_data *hd, int max) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_addspiritball_pre ) {
		void (*preHookFunc) (struct homun_data **hd, int *max);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.addspiritball(hd, max);
	}
	if( HPMHooks.count.HP_homun_addspiritball_post ) {
		void (*postHookFunc) (struct homun_data *hd, int max);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_addspiritball_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_addspiritball_post[hIndex].func;
			postHookFunc(hd, max);
		}
	}
	return;
}
void HP_homun_delspiritball(struct homun_data *hd, int count, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_homun_delspiritball_pre ) {
		void (*preHookFunc) (struct homun_data **hd, int *count, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.homun.delspiritball(hd, count, type);
	}
	if( HPMHooks.count.HP_homun_delspiritball_post ) {
		void (*postHookFunc) (struct homun_data *hd, int count, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_delspiritball_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_delspiritball_post[hIndex].func;
			postHookFunc(hd, count, type);
		}
	}
	return;
}
int8 HP_homun_get_intimacy_grade(struct homun_data *hd) {
	int hIndex = 0;
	int8 retVal___ = 0;
	if( HPMHooks.count.HP_homun_get_intimacy_grade_pre ) {
		int8 (*preHookFunc) (struct homun_data **hd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_get_intimacy_grade_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_homun_get_intimacy_grade_pre[hIndex].func;
			retVal___ = preHookFunc(&hd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.homun.get_intimacy_grade(hd);
	}
	if( HPMHooks.count.HP_homun_get_intimacy_grade_post ) {
		int8 (*postHookFunc) (int8 retVal___, struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_homun_get_intimacy_grade_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_homun_get_intimacy_grade_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd);
		}
	}
	return retVal___;
}
/* instance_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.init(minimal);
	}
	if( HPMHooks.count.HP_instance_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.final();
	}
	if( HPMHooks.count.HP_instance_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.reload();
	}
	if( HPMHooks.count.HP_instance_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_instance_create(int party_id, const char *name, enum instance_owner_type type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.instance.create(party_id, name, type);
	}
	if( HPMHooks.count.HP_instance_create_post ) {
		int (*postHookFunc) (int retVal___, int party_id, const char *name, enum instance_owner_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, name, type);
		}
	}
	return retVal___;
}
int HP_instance_add_map(const char *name, int instance_id, bool usebasename, const char *map_name) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.instance.add_map(name, instance_id, usebasename, map_name);
	}
	if( HPMHooks.count.HP_instance_add_map_post ) {
		int (*postHookFunc) (int retVal___, const char *name, int instance_id, bool usebasename, const char *map_name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_add_map_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_add_map_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, instance_id, usebasename, map_name);
		}
	}
	return retVal___;
}
void HP_instance_del_map(int16 m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_instance_del_map_pre ) {
		void (*preHookFunc) (int16 *m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.del_map(m);
	}
	if( HPMHooks.count.HP_instance_del_map_post ) {
		void (*postHookFunc) (int16 m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_del_map_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_del_map_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
int HP_instance_map2imap(int16 m, int instance_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.instance.map2imap(m, instance_id);
	}
	if( HPMHooks.count.HP_instance_map2imap_post ) {
		int (*postHookFunc) (int retVal___, int16 m, int instance_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_map2imap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_map2imap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, instance_id);
		}
	}
	return retVal___;
}
int HP_instance_mapid2imapid(int16 m, int instance_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.instance.mapid2imapid(m, instance_id);
	}
	if( HPMHooks.count.HP_instance_mapid2imapid_post ) {
		int (*postHookFunc) (int retVal___, int16 m, int instance_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_mapid2imapid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_mapid2imapid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, instance_id);
		}
	}
	return retVal___;
}
int HP_instance_mapname2imap(const char *map_name, int instance_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.instance.mapname2imap(map_name, instance_id);
	}
	if( HPMHooks.count.HP_instance_mapname2imap_post ) {
		int (*postHookFunc) (int retVal___, const char *map_name, int instance_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_mapname2imap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_mapname2imap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, map_name, instance_id);
		}
	}
	return retVal___;
}
int HP_instance_map_npcsub(struct block_list *bl, va_list args) {
	int hIndex = 0;
	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;
			retVal___ = preHookFunc(&bl, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.instance.map_npcsub(bl, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_instance_map_npcsub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_map_npcsub_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_instance_map_npcsub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_instance_init_npc(struct block_list *bl, va_list args) {
	int hIndex = 0;
	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;
			retVal___ = preHookFunc(&bl, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.instance.init_npc(bl, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_instance_init_npc_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_init_npc_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_instance_init_npc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.destroy(instance_id);
	}
	if( HPMHooks.count.HP_instance_destroy_post ) {
		void (*postHookFunc) (int instance_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_destroy_post[hIndex].func;
			postHookFunc(instance_id);
		}
	}
	return;
}
void HP_instance_start(int instance_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_instance_start_pre ) {
		void (*preHookFunc) (int *instance_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.start(instance_id);
	}
	if( HPMHooks.count.HP_instance_start_post ) {
		void (*postHookFunc) (int instance_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_start_post[hIndex].func;
			postHookFunc(instance_id);
		}
	}
	return;
}
void HP_instance_check_idle(int instance_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_instance_check_idle_pre ) {
		void (*preHookFunc) (int *instance_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.check_idle(instance_id);
	}
	if( HPMHooks.count.HP_instance_check_idle_post ) {
		void (*postHookFunc) (int instance_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_idle_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_check_idle_post[hIndex].func;
			postHookFunc(instance_id);
		}
	}
	return;
}
void HP_instance_check_kick(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_instance_check_kick_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.check_kick(sd);
	}
	if( HPMHooks.count.HP_instance_check_kick_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_check_kick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_check_kick_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_instance_set_timeout(int instance_id, unsigned int progress_timeout, unsigned int idle_timeout) {
	int hIndex = 0;
	if( HPMHooks.count.HP_instance_set_timeout_pre ) {
		void (*preHookFunc) (int *instance_id, unsigned int *progress_timeout, unsigned int *idle_timeout);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.instance.set_timeout(instance_id, progress_timeout, idle_timeout);
	}
	if( HPMHooks.count.HP_instance_set_timeout_post ) {
		void (*postHookFunc) (int instance_id, unsigned int progress_timeout, unsigned int idle_timeout);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_set_timeout_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_set_timeout_post[hIndex].func;
			postHookFunc(instance_id, progress_timeout, idle_timeout);
		}
	}
	return;
}
bool HP_instance_valid(int instance_id) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.instance.valid(instance_id);
	}
	if( HPMHooks.count.HP_instance_valid_post ) {
		bool (*postHookFunc) (bool retVal___, int instance_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_valid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_valid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, instance_id);
		}
	}
	return retVal___;
}
int HP_instance_destroy_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.instance.destroy_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_instance_destroy_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_instance_destroy_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_instance_destroy_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
/* intif_interface */
int HP_intif_parse(int fd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.parse(fd);
	}
	if( HPMHooks.count.HP_intif_parse_post ) {
		int (*postHookFunc) (int retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_parse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_parse_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
int HP_intif_create_pet(int account_id, int char_id, short pet_type, short pet_lv, short pet_egg_id, short pet_equip, short intimate, short hungry, char rename_flag, char incubate, char *pet_name) {
	int hIndex = 0;
	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 *incubate, 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, &incubate, &pet_name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.create_pet(account_id, char_id, pet_type, pet_lv, pet_egg_id, pet_equip, intimate, hungry, rename_flag, incubate, pet_name);
	}
	if( HPMHooks.count.HP_intif_create_pet_post ) {
		int (*postHookFunc) (int retVal___, int account_id, int char_id, short pet_type, short pet_lv, short pet_egg_id, short pet_equip, short intimate, short hungry, char rename_flag, char incubate, char *pet_name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_pet_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_create_pet_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, char_id, pet_type, pet_lv, pet_egg_id, pet_equip, intimate, hungry, rename_flag, incubate, pet_name);
		}
	}
	return retVal___;
}
int HP_intif_broadcast(const char *mes, int len, int type) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_intif_broadcast_pre ) {
		int (*preHookFunc) (const char **mes, int *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.broadcast(mes, len, type);
	}
	if( HPMHooks.count.HP_intif_broadcast_post ) {
		int (*postHookFunc) (int retVal___, const char *mes, int len, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_broadcast_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mes, len, type);
		}
	}
	return retVal___;
}
int HP_intif_broadcast2(const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_intif_broadcast2_pre ) {
		int (*preHookFunc) (const char **mes, int *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.broadcast2(mes, len, fontColor, fontType, fontSize, fontAlign, fontY);
	}
	if( HPMHooks.count.HP_intif_broadcast2_post ) {
		int (*postHookFunc) (int retVal___, const char *mes, int len, unsigned int fontColor, short fontType, short fontSize, short fontAlign, short fontY);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_broadcast2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_broadcast2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mes, len, fontColor, fontType, fontSize, fontAlign, fontY);
		}
	}
	return retVal___;
}
int HP_intif_main_message(struct map_session_data *sd, const char *message) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.main_message(sd, message);
	}
	if( HPMHooks.count.HP_intif_main_message_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_main_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_main_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, message);
		}
	}
	return retVal___;
}
int HP_intif_wis_message(struct map_session_data *sd, const char *nick, const char *mes, int mes_len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_intif_wis_message_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const char **nick, const char **mes, int *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.wis_message(sd, nick, mes, mes_len);
	}
	if( HPMHooks.count.HP_intif_wis_message_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *nick, const char *mes, int mes_len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_wis_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nick, mes, mes_len);
		}
	}
	return retVal___;
}
int HP_intif_wis_message_to_gm(char *Wisp_name, int permission, char *mes) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.wis_message_to_gm(Wisp_name, permission, mes);
	}
	if( HPMHooks.count.HP_intif_wis_message_to_gm_post ) {
		int (*postHookFunc) (int retVal___, char *Wisp_name, int permission, char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_wis_message_to_gm_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_wis_message_to_gm_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, Wisp_name, permission, mes);
		}
	}
	return retVal___;
}
int HP_intif_saveregistry(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.saveregistry(sd);
	}
	if( HPMHooks.count.HP_intif_saveregistry_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_saveregistry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_saveregistry_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_intif_request_registry(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.request_registry(sd, flag);
	}
	if( HPMHooks.count.HP_intif_request_registry_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_registry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_request_registry_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, flag);
		}
	}
	return retVal___;
}
int HP_intif_request_guild_storage(int account_id, int guild_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.request_guild_storage(account_id, guild_id);
	}
	if( HPMHooks.count.HP_intif_request_guild_storage_post ) {
		int (*postHookFunc) (int retVal___, int account_id, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_guild_storage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_request_guild_storage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, guild_id);
		}
	}
	return retVal___;
}
int HP_intif_send_guild_storage(int account_id, struct guild_storage *gstor) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.send_guild_storage(account_id, gstor);
	}
	if( HPMHooks.count.HP_intif_send_guild_storage_post ) {
		int (*postHookFunc) (int retVal___, int account_id, struct guild_storage *gstor);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_send_guild_storage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_send_guild_storage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, gstor);
		}
	}
	return retVal___;
}
int HP_intif_create_party(struct party_member *member, const char *name, int item, int item2) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_intif_create_party_pre ) {
		int (*preHookFunc) (struct party_member **member, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.create_party(member, name, item, item2);
	}
	if( HPMHooks.count.HP_intif_create_party_post ) {
		int (*postHookFunc) (int retVal___, struct party_member *member, const char *name, int item, int item2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_create_party_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_create_party_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, member, name, item, item2);
		}
	}
	return retVal___;
}
int HP_intif_request_partyinfo(int party_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.request_partyinfo(party_id, char_id);
	}
	if( HPMHooks.count.HP_intif_request_partyinfo_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_partyinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_request_partyinfo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, char_id);
		}
	}
	return retVal___;
}
int HP_intif_party_addmember(int party_id, struct party_member *member) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.party_addmember(party_id, member);
	}
	if( HPMHooks.count.HP_intif_party_addmember_post ) {
		int (*postHookFunc) (int retVal___, int party_id, struct party_member *member);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_addmember_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_party_addmember_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, member);
		}
	}
	return retVal___;
}
int HP_intif_party_changeoption(int party_id, int account_id, int exp, int item) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.party_changeoption(party_id, account_id, exp, item);
	}
	if( HPMHooks.count.HP_intif_party_changeoption_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, int exp, int item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changeoption_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_party_changeoption_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, exp, item);
		}
	}
	return retVal___;
}
int HP_intif_party_leave(int party_id, int account_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.party_leave(party_id, account_id, char_id);
	}
	if( HPMHooks.count.HP_intif_party_leave_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_party_leave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, char_id);
		}
	}
	return retVal___;
}
int HP_intif_party_changemap(struct map_session_data *sd, int online) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.party_changemap(sd, online);
	}
	if( HPMHooks.count.HP_intif_party_changemap_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int online);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_changemap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_party_changemap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, online);
		}
	}
	return retVal___;
}
int HP_intif_break_party(int party_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.break_party(party_id);
	}
	if( HPMHooks.count.HP_intif_break_party_post ) {
		int (*postHookFunc) (int retVal___, int party_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_break_party_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_break_party_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id);
		}
	}
	return retVal___;
}
int HP_intif_party_message(int party_id, int account_id, const char *mes, int len) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.party_message(party_id, account_id, mes, len);
	}
	if( HPMHooks.count.HP_intif_party_message_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, const char *mes, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_party_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, mes, len);
		}
	}
	return retVal___;
}
int HP_intif_party_leaderchange(int party_id, int account_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.party_leaderchange(party_id, account_id, char_id);
	}
	if( HPMHooks.count.HP_intif_party_leaderchange_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_party_leaderchange_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_party_leaderchange_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, char_id);
		}
	}
	return retVal___;
}
int HP_intif_guild_create(const char *name, const struct guild_member *master) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_create(name, master);
	}
	if( HPMHooks.count.HP_intif_guild_create_post ) {
		int (*postHookFunc) (int retVal___, const char *name, const struct guild_member *master);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, master);
		}
	}
	return retVal___;
}
int HP_intif_guild_request_info(int guild_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_request_info(guild_id);
	}
	if( HPMHooks.count.HP_intif_guild_request_info_post ) {
		int (*postHookFunc) (int retVal___, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_request_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_request_info_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id);
		}
	}
	return retVal___;
}
int HP_intif_guild_addmember(int guild_id, struct guild_member *m) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_addmember(guild_id, m);
	}
	if( HPMHooks.count.HP_intif_guild_addmember_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, struct guild_member *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_addmember_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_addmember_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, m);
		}
	}
	return retVal___;
}
int HP_intif_guild_leave(int guild_id, int account_id, int char_id, int flag, const char *mes) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_leave(guild_id, account_id, char_id, flag, mes);
	}
	if( HPMHooks.count.HP_intif_guild_leave_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int flag, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_leave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, flag, mes);
		}
	}
	return retVal___;
}
int HP_intif_guild_memberinfoshort(int guild_id, int account_id, int char_id, int online, int lv, int class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_memberinfoshort(guild_id, account_id, char_id, online, lv, class_);
	}
	if( HPMHooks.count.HP_intif_guild_memberinfoshort_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int online, int lv, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_memberinfoshort_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_memberinfoshort_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, online, lv, class_);
		}
	}
	return retVal___;
}
int HP_intif_guild_break(int guild_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_break(guild_id);
	}
	if( HPMHooks.count.HP_intif_guild_break_post ) {
		int (*postHookFunc) (int retVal___, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_break_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_break_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id);
		}
	}
	return retVal___;
}
int HP_intif_guild_message(int guild_id, int account_id, const char *mes, int len) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_message(guild_id, account_id, mes, len);
	}
	if( HPMHooks.count.HP_intif_guild_message_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, const char *mes, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, mes, len);
		}
	}
	return retVal___;
}
int HP_intif_guild_change_gm(int guild_id, const char *name, int len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_intif_guild_change_gm_pre ) {
		int (*preHookFunc) (int *guild_id, const char **name, int *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_change_gm(guild_id, name, len);
	}
	if( HPMHooks.count.HP_intif_guild_change_gm_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, const char *name, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_gm_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_change_gm_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, name, len);
		}
	}
	return retVal___;
}
int HP_intif_guild_change_basicinfo(int guild_id, int type, const void *data, int len) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_change_basicinfo(guild_id, type, data, len);
	}
	if( HPMHooks.count.HP_intif_guild_change_basicinfo_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int type, const void *data, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_basicinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_change_basicinfo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, type, data, len);
		}
	}
	return retVal___;
}
int HP_intif_guild_change_memberinfo(int guild_id, int account_id, int char_id, int type, const void *data, int len) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_change_memberinfo(guild_id, account_id, char_id, type, data, len);
	}
	if( HPMHooks.count.HP_intif_guild_change_memberinfo_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int account_id, int char_id, int type, const void *data, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_change_memberinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_change_memberinfo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, account_id, char_id, type, data, len);
		}
	}
	return retVal___;
}
int HP_intif_guild_position(int guild_id, int idx, struct guild_position *p) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_position(guild_id, idx, p);
	}
	if( HPMHooks.count.HP_intif_guild_position_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int idx, struct guild_position *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_position_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_position_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, idx, p);
		}
	}
	return retVal___;
}
int HP_intif_guild_skillup(int guild_id, uint16 skill_id, int account_id, int max) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_skillup(guild_id, skill_id, account_id, max);
	}
	if( HPMHooks.count.HP_intif_guild_skillup_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, uint16 skill_id, int account_id, int max);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_skillup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_skillup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, skill_id, account_id, max);
		}
	}
	return retVal___;
}
int HP_intif_guild_alliance(int guild_id1, int guild_id2, int account_id1, int account_id2, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_alliance(guild_id1, guild_id2, account_id1, account_id2, flag);
	}
	if( HPMHooks.count.HP_intif_guild_alliance_post ) {
		int (*postHookFunc) (int retVal___, int guild_id1, int guild_id2, int account_id1, int account_id2, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_alliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_alliance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id1, guild_id2, account_id1, account_id2, flag);
		}
	}
	return retVal___;
}
int HP_intif_guild_notice(int guild_id, const char *mes1, const char *mes2) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_notice(guild_id, mes1, mes2);
	}
	if( HPMHooks.count.HP_intif_guild_notice_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, const char *mes1, const char *mes2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_notice_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_notice_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, mes1, mes2);
		}
	}
	return retVal___;
}
int HP_intif_guild_emblem(int guild_id, int len, const char *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_emblem(guild_id, len, data);
	}
	if( HPMHooks.count.HP_intif_guild_emblem_post ) {
		int (*postHookFunc) (int retVal___, int guild_id, int len, const char *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_emblem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_emblem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, guild_id, len, data);
		}
	}
	return retVal___;
}
int HP_intif_guild_castle_dataload(int num, int *castle_ids) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_castle_dataload(num, castle_ids);
	}
	if( HPMHooks.count.HP_intif_guild_castle_dataload_post ) {
		int (*postHookFunc) (int retVal___, int num, int *castle_ids);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_dataload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_castle_dataload_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, num, castle_ids);
		}
	}
	return retVal___;
}
int HP_intif_guild_castle_datasave(int castle_id, int index, int value) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.guild_castle_datasave(castle_id, index, value);
	}
	if( HPMHooks.count.HP_intif_guild_castle_datasave_post ) {
		int (*postHookFunc) (int retVal___, int castle_id, int index, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_guild_castle_datasave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_guild_castle_datasave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, castle_id, index, value);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.itembound_req(char_id, aid, guild_id);
	}
	if( HPMHooks.count.HP_intif_itembound_req_post ) {
		void (*postHookFunc) (int char_id, int aid, int guild_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_itembound_req_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_itembound_req_post[hIndex].func;
			postHookFunc(char_id, aid, guild_id);
		}
	}
	return;
}
int HP_intif_request_petdata(int account_id, int char_id, int pet_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.request_petdata(account_id, char_id, pet_id);
	}
	if( HPMHooks.count.HP_intif_request_petdata_post ) {
		int (*postHookFunc) (int retVal___, int account_id, int char_id, int pet_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_petdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_request_petdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, char_id, pet_id);
		}
	}
	return retVal___;
}
int HP_intif_save_petdata(int account_id, struct s_pet *p) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.save_petdata(account_id, p);
	}
	if( HPMHooks.count.HP_intif_save_petdata_post ) {
		int (*postHookFunc) (int retVal___, int account_id, struct s_pet *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_save_petdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_save_petdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, p);
		}
	}
	return retVal___;
}
int HP_intif_delete_petdata(int pet_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.delete_petdata(pet_id);
	}
	if( HPMHooks.count.HP_intif_delete_petdata_post ) {
		int (*postHookFunc) (int retVal___, int pet_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_delete_petdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_delete_petdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pet_id);
		}
	}
	return retVal___;
}
int HP_intif_rename(struct map_session_data *sd, int type, const char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_intif_rename_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, int *type, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.rename(sd, type, name);
	}
	if( HPMHooks.count.HP_intif_rename_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_rename_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_rename_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, name);
		}
	}
	return retVal___;
}
int HP_intif_homunculus_create(int account_id, struct s_homunculus *sh) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.homunculus_create(account_id, sh);
	}
	if( HPMHooks.count.HP_intif_homunculus_create_post ) {
		int (*postHookFunc) (int retVal___, int account_id, struct s_homunculus *sh);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_homunculus_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, sh);
		}
	}
	return retVal___;
}
bool HP_intif_homunculus_requestload(int account_id, int homun_id) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.homunculus_requestload(account_id, homun_id);
	}
	if( HPMHooks.count.HP_intif_homunculus_requestload_post ) {
		bool (*postHookFunc) (bool retVal___, int account_id, int homun_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_homunculus_requestload_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, homun_id);
		}
	}
	return retVal___;
}
int HP_intif_homunculus_requestsave(int account_id, struct s_homunculus *sh) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.homunculus_requestsave(account_id, sh);
	}
	if( HPMHooks.count.HP_intif_homunculus_requestsave_post ) {
		int (*postHookFunc) (int retVal___, int account_id, struct s_homunculus *sh);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestsave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_homunculus_requestsave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, sh);
		}
	}
	return retVal___;
}
int HP_intif_homunculus_requestdelete(int homun_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.homunculus_requestdelete(homun_id);
	}
	if( HPMHooks.count.HP_intif_homunculus_requestdelete_post ) {
		int (*postHookFunc) (int retVal___, int homun_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_homunculus_requestdelete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_homunculus_requestdelete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, homun_id);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.request_questlog(sd);
	}
	if( HPMHooks.count.HP_intif_request_questlog_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_questlog_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_request_questlog_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_intif_quest_save(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.quest_save(sd);
	}
	if( HPMHooks.count.HP_intif_quest_save_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_quest_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_quest_save_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_intif_mercenary_create(struct s_mercenary *merc) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.mercenary_create(merc);
	}
	if( HPMHooks.count.HP_intif_mercenary_create_post ) {
		int (*postHookFunc) (int retVal___, struct s_mercenary *merc);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_mercenary_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, merc);
		}
	}
	return retVal___;
}
int HP_intif_mercenary_request(int merc_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.mercenary_request(merc_id, char_id);
	}
	if( HPMHooks.count.HP_intif_mercenary_request_post ) {
		int (*postHookFunc) (int retVal___, int merc_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_request_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_mercenary_request_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, merc_id, char_id);
		}
	}
	return retVal___;
}
int HP_intif_mercenary_delete(int merc_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.mercenary_delete(merc_id);
	}
	if( HPMHooks.count.HP_intif_mercenary_delete_post ) {
		int (*postHookFunc) (int retVal___, int merc_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_mercenary_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, merc_id);
		}
	}
	return retVal___;
}
int HP_intif_mercenary_save(struct s_mercenary *merc) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.mercenary_save(merc);
	}
	if( HPMHooks.count.HP_intif_mercenary_save_post ) {
		int (*postHookFunc) (int retVal___, struct s_mercenary *merc);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_mercenary_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_mercenary_save_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, merc);
		}
	}
	return retVal___;
}
int HP_intif_Mail_requestinbox(int char_id, unsigned char flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Mail_requestinbox(char_id, flag);
	}
	if( HPMHooks.count.HP_intif_Mail_requestinbox_post ) {
		int (*postHookFunc) (int retVal___, int char_id, unsigned char flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_requestinbox_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Mail_requestinbox_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, flag);
		}
	}
	return retVal___;
}
int HP_intif_Mail_read(int mail_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Mail_read(mail_id);
	}
	if( HPMHooks.count.HP_intif_Mail_read_post ) {
		int (*postHookFunc) (int retVal___, int mail_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Mail_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mail_id);
		}
	}
	return retVal___;
}
int HP_intif_Mail_getattach(int char_id, int mail_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Mail_getattach(char_id, mail_id);
	}
	if( HPMHooks.count.HP_intif_Mail_getattach_post ) {
		int (*postHookFunc) (int retVal___, int char_id, int mail_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_getattach_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Mail_getattach_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, mail_id);
		}
	}
	return retVal___;
}
int HP_intif_Mail_delete(int char_id, int mail_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Mail_delete(char_id, mail_id);
	}
	if( HPMHooks.count.HP_intif_Mail_delete_post ) {
		int (*postHookFunc) (int retVal___, int char_id, int mail_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Mail_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, mail_id);
		}
	}
	return retVal___;
}
int HP_intif_Mail_return(int char_id, int mail_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Mail_return(char_id, mail_id);
	}
	if( HPMHooks.count.HP_intif_Mail_return_post ) {
		int (*postHookFunc) (int retVal___, int char_id, int mail_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_return_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Mail_return_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, mail_id);
		}
	}
	return retVal___;
}
int HP_intif_Mail_send(int account_id, struct mail_message *msg) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Mail_send(account_id, msg);
	}
	if( HPMHooks.count.HP_intif_Mail_send_post ) {
		int (*postHookFunc) (int retVal___, int account_id, struct mail_message *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Mail_send_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Mail_send_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, msg);
		}
	}
	return retVal___;
}
int HP_intif_Auction_requestlist(int char_id, short type, int price, const char *searchtext, short page) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Auction_requestlist(char_id, type, price, searchtext, page);
	}
	if( HPMHooks.count.HP_intif_Auction_requestlist_post ) {
		int (*postHookFunc) (int retVal___, int char_id, short type, int price, const char *searchtext, short page);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_requestlist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Auction_requestlist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, type, price, searchtext, page);
		}
	}
	return retVal___;
}
int HP_intif_Auction_register(struct auction_data *auction) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Auction_register(auction);
	}
	if( HPMHooks.count.HP_intif_Auction_register_post ) {
		int (*postHookFunc) (int retVal___, struct auction_data *auction);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_register_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Auction_register_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, auction);
		}
	}
	return retVal___;
}
int HP_intif_Auction_cancel(int char_id, unsigned int auction_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Auction_cancel(char_id, auction_id);
	}
	if( HPMHooks.count.HP_intif_Auction_cancel_post ) {
		int (*postHookFunc) (int retVal___, int char_id, unsigned int auction_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_cancel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Auction_cancel_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, auction_id);
		}
	}
	return retVal___;
}
int HP_intif_Auction_close(int char_id, unsigned int auction_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Auction_close(char_id, auction_id);
	}
	if( HPMHooks.count.HP_intif_Auction_close_post ) {
		int (*postHookFunc) (int retVal___, int char_id, unsigned int auction_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Auction_close_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, auction_id);
		}
	}
	return retVal___;
}
int HP_intif_Auction_bid(int char_id, const char *name, unsigned int auction_id, int bid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.Auction_bid(char_id, name, auction_id, bid);
	}
	if( HPMHooks.count.HP_intif_Auction_bid_post ) {
		int (*postHookFunc) (int retVal___, int char_id, const char *name, unsigned int auction_id, int bid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_Auction_bid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_Auction_bid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, name, auction_id, bid);
		}
	}
	return retVal___;
}
int HP_intif_elemental_create(struct s_elemental *ele) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.elemental_create(ele);
	}
	if( HPMHooks.count.HP_intif_elemental_create_post ) {
		int (*postHookFunc) (int retVal___, struct s_elemental *ele);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_elemental_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ele);
		}
	}
	return retVal___;
}
int HP_intif_elemental_request(int ele_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.elemental_request(ele_id, char_id);
	}
	if( HPMHooks.count.HP_intif_elemental_request_post ) {
		int (*postHookFunc) (int retVal___, int ele_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_request_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_elemental_request_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ele_id, char_id);
		}
	}
	return retVal___;
}
int HP_intif_elemental_delete(int ele_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.elemental_delete(ele_id);
	}
	if( HPMHooks.count.HP_intif_elemental_delete_post ) {
		int (*postHookFunc) (int retVal___, int ele_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_elemental_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ele_id);
		}
	}
	return retVal___;
}
int HP_intif_elemental_save(struct s_elemental *ele) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.elemental_save(ele);
	}
	if( HPMHooks.count.HP_intif_elemental_save_post ) {
		int (*postHookFunc) (int retVal___, struct s_elemental *ele);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_elemental_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_elemental_save_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ele);
		}
	}
	return retVal___;
}
void HP_intif_request_accinfo(int u_fd, int aid, int group_lv, char *query) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_request_accinfo_pre ) {
		void (*preHookFunc) (int *u_fd, int *aid, int *group_lv, char **query);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.request_accinfo(u_fd, aid, group_lv, query);
	}
	if( HPMHooks.count.HP_intif_request_accinfo_post ) {
		void (*postHookFunc) (int u_fd, int aid, int group_lv, char *query);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_request_accinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_request_accinfo_post[hIndex].func;
			postHookFunc(u_fd, aid, group_lv, query);
		}
	}
	return;
}
int HP_intif_CheckForCharServer(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.intif.CheckForCharServer();
	}
	if( HPMHooks.count.HP_intif_CheckForCharServer_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_CheckForCharServer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_CheckForCharServer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_intif_pWisMessage(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pWisMessage_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pWisMessage(fd);
	}
	if( HPMHooks.count.HP_intif_pWisMessage_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pWisMessage_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pWisEnd(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pWisEnd_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pWisEnd(fd);
	}
	if( HPMHooks.count.HP_intif_pWisEnd_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisEnd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pWisEnd_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
int HP_intif_pWisToGM_sub(struct map_session_data *sd, va_list va) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, va___copy);
			va_end(va___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list va___copy; va_copy(va___copy, va);
		retVal___ = HPMHooks.source.intif.pWisToGM_sub(sd, va___copy);
		va_end(va___copy);
	}
	if( HPMHooks.count.HP_intif_pWisToGM_sub_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list va);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_sub_post; hIndex++ ) {
			va_list va___copy; va_copy(va___copy, va);
			postHookFunc = HPMHooks.list.HP_intif_pWisToGM_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, va___copy);
			va_end(va___copy);
		}
	}
	return retVal___;
}
void HP_intif_pWisToGM(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pWisToGM_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pWisToGM(fd);
	}
	if( HPMHooks.count.HP_intif_pWisToGM_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pWisToGM_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pWisToGM_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pRegisters(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pRegisters_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pRegisters(fd);
	}
	if( HPMHooks.count.HP_intif_pRegisters_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRegisters_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pRegisters_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pChangeNameOk(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pChangeNameOk_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pChangeNameOk(fd);
	}
	if( HPMHooks.count.HP_intif_pChangeNameOk_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pChangeNameOk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pChangeNameOk_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMessageToFD(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMessageToFD_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMessageToFD(fd);
	}
	if( HPMHooks.count.HP_intif_pMessageToFD_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMessageToFD_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMessageToFD_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pLoadGuildStorage(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pLoadGuildStorage_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pLoadGuildStorage(fd);
	}
	if( HPMHooks.count.HP_intif_pLoadGuildStorage_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pLoadGuildStorage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pLoadGuildStorage_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pSaveGuildStorage(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pSaveGuildStorage_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pSaveGuildStorage(fd);
	}
	if( HPMHooks.count.HP_intif_pSaveGuildStorage_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveGuildStorage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pSaveGuildStorage_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pPartyCreated(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pPartyCreated_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pPartyCreated(fd);
	}
	if( HPMHooks.count.HP_intif_pPartyCreated_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyCreated_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pPartyCreated_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pPartyInfo(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pPartyInfo_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pPartyInfo(fd);
	}
	if( HPMHooks.count.HP_intif_pPartyInfo_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pPartyInfo_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pPartyMemberAdded(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pPartyMemberAdded_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pPartyMemberAdded(fd);
	}
	if( HPMHooks.count.HP_intif_pPartyMemberAdded_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberAdded_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pPartyMemberAdded_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pPartyOptionChanged(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pPartyOptionChanged_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pPartyOptionChanged(fd);
	}
	if( HPMHooks.count.HP_intif_pPartyOptionChanged_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyOptionChanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pPartyOptionChanged_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pPartyMemberWithdraw(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pPartyMemberWithdraw_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pPartyMemberWithdraw(fd);
	}
	if( HPMHooks.count.HP_intif_pPartyMemberWithdraw_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMemberWithdraw_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pPartyMemberWithdraw_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pPartyMove(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pPartyMove_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pPartyMove(fd);
	}
	if( HPMHooks.count.HP_intif_pPartyMove_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pPartyMove_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pPartyBroken(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pPartyBroken_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pPartyBroken(fd);
	}
	if( HPMHooks.count.HP_intif_pPartyBroken_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyBroken_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pPartyBroken_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pPartyMessage(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pPartyMessage_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pPartyMessage(fd);
	}
	if( HPMHooks.count.HP_intif_pPartyMessage_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pPartyMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pPartyMessage_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildCreated(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildCreated_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildCreated(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildCreated_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCreated_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildCreated_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildInfo(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildInfo_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildInfo(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildInfo_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildInfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildInfo_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildMemberAdded(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildMemberAdded_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildMemberAdded(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildMemberAdded_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberAdded_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildMemberAdded_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildMemberWithdraw(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildMemberWithdraw_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildMemberWithdraw(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildMemberWithdraw_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberWithdraw_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildMemberWithdraw_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildMemberInfoShort(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildMemberInfoShort_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildMemberInfoShort(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildMemberInfoShort_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoShort_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoShort_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildBroken(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildBroken_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildBroken(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildBroken_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBroken_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildBroken_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildMessage(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildMessage_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildMessage(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildMessage_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildMessage_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildBasicInfoChanged(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildBasicInfoChanged_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildBasicInfoChanged(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildBasicInfoChanged_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildBasicInfoChanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildBasicInfoChanged_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildMemberInfoChanged(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildMemberInfoChanged_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildMemberInfoChanged(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildMemberInfoChanged_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMemberInfoChanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildMemberInfoChanged_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildPosition(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildPosition_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildPosition(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildPosition_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildPosition_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildPosition_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildSkillUp(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildSkillUp_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildSkillUp(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildSkillUp_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildSkillUp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildSkillUp_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildAlliance(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildAlliance_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildAlliance(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildAlliance_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildAlliance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildAlliance_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildNotice(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildNotice_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildNotice(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildNotice_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildNotice_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildNotice_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildEmblem(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildEmblem_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildEmblem(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildEmblem_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildEmblem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildEmblem_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildCastleDataLoad(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildCastleDataLoad_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildCastleDataLoad(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildCastleDataLoad_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildCastleDataLoad_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildCastleDataLoad_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pGuildMasterChanged(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pGuildMasterChanged_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pGuildMasterChanged(fd);
	}
	if( HPMHooks.count.HP_intif_pGuildMasterChanged_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pGuildMasterChanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pGuildMasterChanged_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pQuestLog(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pQuestLog_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pQuestLog(fd);
	}
	if( HPMHooks.count.HP_intif_pQuestLog_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestLog_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pQuestLog_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pQuestSave(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pQuestSave_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pQuestSave(fd);
	}
	if( HPMHooks.count.HP_intif_pQuestSave_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pQuestSave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pQuestSave_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMailInboxReceived(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMailInboxReceived_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMailInboxReceived(fd);
	}
	if( HPMHooks.count.HP_intif_pMailInboxReceived_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailInboxReceived_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMailInboxReceived_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMailNew(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMailNew_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMailNew(fd);
	}
	if( HPMHooks.count.HP_intif_pMailNew_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailNew_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMailNew_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMailGetAttach(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMailGetAttach_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMailGetAttach(fd);
	}
	if( HPMHooks.count.HP_intif_pMailGetAttach_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailGetAttach_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMailGetAttach_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMailDelete(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMailDelete_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMailDelete(fd);
	}
	if( HPMHooks.count.HP_intif_pMailDelete_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailDelete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMailDelete_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMailReturn(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMailReturn_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMailReturn(fd);
	}
	if( HPMHooks.count.HP_intif_pMailReturn_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailReturn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMailReturn_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMailSend(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMailSend_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMailSend(fd);
	}
	if( HPMHooks.count.HP_intif_pMailSend_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMailSend_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMailSend_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pAuctionResults(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pAuctionResults_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pAuctionResults(fd);
	}
	if( HPMHooks.count.HP_intif_pAuctionResults_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionResults_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pAuctionResults_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pAuctionRegister(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pAuctionRegister_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pAuctionRegister(fd);
	}
	if( HPMHooks.count.HP_intif_pAuctionRegister_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionRegister_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pAuctionRegister_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pAuctionCancel(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pAuctionCancel_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pAuctionCancel(fd);
	}
	if( HPMHooks.count.HP_intif_pAuctionCancel_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionCancel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pAuctionCancel_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pAuctionClose(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pAuctionClose_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pAuctionClose(fd);
	}
	if( HPMHooks.count.HP_intif_pAuctionClose_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionClose_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pAuctionClose_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pAuctionMessage(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pAuctionMessage_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pAuctionMessage(fd);
	}
	if( HPMHooks.count.HP_intif_pAuctionMessage_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionMessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pAuctionMessage_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pAuctionBid(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pAuctionBid_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pAuctionBid(fd);
	}
	if( HPMHooks.count.HP_intif_pAuctionBid_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pAuctionBid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pAuctionBid_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pItembound_ack(fd);
	}
	if( HPMHooks.count.HP_intif_pItembound_ack_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pItembound_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pItembound_ack_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMercenaryReceived(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMercenaryReceived_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMercenaryReceived(fd);
	}
	if( HPMHooks.count.HP_intif_pMercenaryReceived_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryReceived_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMercenaryReceived_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMercenaryDeleted(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMercenaryDeleted_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMercenaryDeleted(fd);
	}
	if( HPMHooks.count.HP_intif_pMercenaryDeleted_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenaryDeleted_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMercenaryDeleted_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pMercenarySaved(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pMercenarySaved_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pMercenarySaved(fd);
	}
	if( HPMHooks.count.HP_intif_pMercenarySaved_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pMercenarySaved_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pMercenarySaved_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pElementalReceived(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pElementalReceived_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pElementalReceived(fd);
	}
	if( HPMHooks.count.HP_intif_pElementalReceived_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalReceived_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pElementalReceived_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pElementalDeleted(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pElementalDeleted_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pElementalDeleted(fd);
	}
	if( HPMHooks.count.HP_intif_pElementalDeleted_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalDeleted_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pElementalDeleted_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pElementalSaved(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pElementalSaved_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pElementalSaved(fd);
	}
	if( HPMHooks.count.HP_intif_pElementalSaved_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pElementalSaved_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pElementalSaved_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pCreatePet(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pCreatePet_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pCreatePet(fd);
	}
	if( HPMHooks.count.HP_intif_pCreatePet_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreatePet_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pCreatePet_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pRecvPetData(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pRecvPetData_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pRecvPetData(fd);
	}
	if( HPMHooks.count.HP_intif_pRecvPetData_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvPetData_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pRecvPetData_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pSavePetOk(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pSavePetOk_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pSavePetOk(fd);
	}
	if( HPMHooks.count.HP_intif_pSavePetOk_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSavePetOk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pSavePetOk_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pDeletePetOk(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pDeletePetOk_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pDeletePetOk(fd);
	}
	if( HPMHooks.count.HP_intif_pDeletePetOk_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeletePetOk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pDeletePetOk_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pCreateHomunculus(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pCreateHomunculus_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pCreateHomunculus(fd);
	}
	if( HPMHooks.count.HP_intif_pCreateHomunculus_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pCreateHomunculus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pCreateHomunculus_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pRecvHomunculusData(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pRecvHomunculusData_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pRecvHomunculusData(fd);
	}
	if( HPMHooks.count.HP_intif_pRecvHomunculusData_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pRecvHomunculusData_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pRecvHomunculusData_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pSaveHomunculusOk(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pSaveHomunculusOk_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pSaveHomunculusOk(fd);
	}
	if( HPMHooks.count.HP_intif_pSaveHomunculusOk_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pSaveHomunculusOk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pSaveHomunculusOk_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_intif_pDeleteHomunculusOk(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_intif_pDeleteHomunculusOk_pre ) {
		void (*preHookFunc) (int *fd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.intif.pDeleteHomunculusOk(fd);
	}
	if( HPMHooks.count.HP_intif_pDeleteHomunculusOk_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_intif_pDeleteHomunculusOk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_intif_pDeleteHomunculusOk_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
/* irc_bot_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.init(minimal);
	}
	if( HPMHooks.count.HP_ircbot_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.final();
	}
	if( HPMHooks.count.HP_ircbot_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_ircbot_parse(int fd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.ircbot.parse(fd);
	}
	if( HPMHooks.count.HP_ircbot_parse_post ) {
		int (*postHookFunc) (int retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_parse_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
void HP_ircbot_parse_sub(int fd, char *str) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_parse_sub_pre ) {
		void (*preHookFunc) (int *fd, char **str);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.parse_sub(fd, str);
	}
	if( HPMHooks.count.HP_ircbot_parse_sub_post ) {
		void (*postHookFunc) (int fd, char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_parse_sub_post[hIndex].func;
			postHookFunc(fd, str);
		}
	}
	return;
}
void HP_ircbot_parse_source(char *source, char *nick, char *ident, char *host) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_parse_source_pre ) {
		void (*preHookFunc) (char **source, char **nick, char **ident, char **host);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.parse_source(source, nick, ident, host);
	}
	if( HPMHooks.count.HP_ircbot_parse_source_post ) {
		void (*postHookFunc) (char *source, char *nick, char *ident, char *host);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_parse_source_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_parse_source_post[hIndex].func;
			postHookFunc(source, nick, ident, host);
		}
	}
	return;
}
struct irc_func* HP_ircbot_func_search(char *function_name) {
	int hIndex = 0;
	struct irc_func* retVal___ = NULL;
	if( HPMHooks.count.HP_ircbot_func_search_pre ) {
		struct irc_func* (*preHookFunc) (char **function_name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.ircbot.func_search(function_name);
	}
	if( HPMHooks.count.HP_ircbot_func_search_post ) {
		struct irc_func* (*postHookFunc) (struct irc_func* retVal___, char *function_name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_func_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_func_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, function_name);
		}
	}
	return retVal___;
}
int HP_ircbot_connect_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.ircbot.connect_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_ircbot_connect_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_connect_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_connect_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_ircbot_identify_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.ircbot.identify_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_ircbot_identify_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_identify_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_identify_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_ircbot_join_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.ircbot.join_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_ircbot_join_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_join_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_join_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_ircbot_queue_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_ircbot_queue_timer_pre ) {
		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_queue_timer_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_ircbot_queue_timer_pre[hIndex].func;
			retVal___ = preHookFunc(&tid, &tick, &id, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.ircbot.queue_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_ircbot_queue_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_queue_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_queue_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_ircbot_queue(char *str) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_queue_pre ) {
		void (*preHookFunc) (char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_queue_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_ircbot_queue_pre[hIndex].func;
			preHookFunc(&str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.queue(str);
	}
	if( HPMHooks.count.HP_ircbot_queue_post ) {
		void (*postHookFunc) (char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_queue_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_queue_post[hIndex].func;
			postHookFunc(str);
		}
	}
	return;
}
void HP_ircbot_send(char *str, bool force) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_send_pre ) {
		void (*preHookFunc) (char **str, bool *force);
		*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, &force);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.send(str, force);
	}
	if( HPMHooks.count.HP_ircbot_send_post ) {
		void (*postHookFunc) (char *str, bool force);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_send_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_send_post[hIndex].func;
			postHookFunc(str, force);
		}
	}
	return;
}
void HP_ircbot_relay(const char *name, const char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_relay_pre ) {
		void (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.relay(name, msg);
	}
	if( HPMHooks.count.HP_ircbot_relay_post ) {
		void (*postHookFunc) (const char *name, const char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_relay_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_relay_post[hIndex].func;
			postHookFunc(name, msg);
		}
	}
	return;
}
void HP_ircbot_pong(int fd, char *cmd, char *source, char *target, char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_pong_pre ) {
		void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.pong(fd, cmd, source, target, msg);
	}
	if( HPMHooks.count.HP_ircbot_pong_post ) {
		void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_pong_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_pong_post[hIndex].func;
			postHookFunc(fd, cmd, source, target, msg);
		}
	}
	return;
}
void HP_ircbot_privmsg(int fd, char *cmd, char *source, char *target, char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_privmsg_pre ) {
		void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.privmsg(fd, cmd, source, target, msg);
	}
	if( HPMHooks.count.HP_ircbot_privmsg_post ) {
		void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_privmsg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_privmsg_post[hIndex].func;
			postHookFunc(fd, cmd, source, target, msg);
		}
	}
	return;
}
void HP_ircbot_privmsg_ctcp(int fd, char *cmd, char *source, char *target, char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_privmsg_ctcp_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_ctcp_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_ircbot_privmsg_ctcp_pre[hIndex].func;
			preHookFunc(&fd, &cmd, &source, &target, &msg);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.privmsg_ctcp(fd, cmd, source, target, msg);
	}
	if( HPMHooks.count.HP_ircbot_privmsg_ctcp_post ) {
		void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_privmsg_ctcp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_privmsg_ctcp_post[hIndex].func;
			postHookFunc(fd, cmd, source, target, msg);
		}
	}
	return;
}
void HP_ircbot_userjoin(int fd, char *cmd, char *source, char *target, char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_userjoin_pre ) {
		void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.userjoin(fd, cmd, source, target, msg);
	}
	if( HPMHooks.count.HP_ircbot_userjoin_post ) {
		void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userjoin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_userjoin_post[hIndex].func;
			postHookFunc(fd, cmd, source, target, msg);
		}
	}
	return;
}
void HP_ircbot_userleave(int fd, char *cmd, char *source, char *target, char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_userleave_pre ) {
		void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.userleave(fd, cmd, source, target, msg);
	}
	if( HPMHooks.count.HP_ircbot_userleave_post ) {
		void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_userleave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_userleave_post[hIndex].func;
			postHookFunc(fd, cmd, source, target, msg);
		}
	}
	return;
}
void HP_ircbot_usernick(int fd, char *cmd, char *source, char *target, char *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_ircbot_usernick_pre ) {
		void (*preHookFunc) (int *fd, char **cmd, char **source, char **target, char **msg);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.ircbot.usernick(fd, cmd, source, target, msg);
	}
	if( HPMHooks.count.HP_ircbot_usernick_post ) {
		void (*postHookFunc) (int fd, char *cmd, char *source, char *target, char *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_ircbot_usernick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_ircbot_usernick_post[hIndex].func;
			postHookFunc(fd, cmd, source, target, msg);
		}
	}
	return;
}
/* itemdb_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.init(minimal);
	}
	if( HPMHooks.count.HP_itemdb_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.final();
	}
	if( HPMHooks.count.HP_itemdb_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_itemdb_reload(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_reload_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_reload_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_itemdb_reload_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.reload();
	}
	if( HPMHooks.count.HP_itemdb_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_itemdb_name_constants(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_name_constants_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.name_constants();
	}
	if( HPMHooks.count.HP_itemdb_name_constants_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name_constants_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_name_constants_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_itemdb_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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.read_groups();
	}
	if( HPMHooks.count.HP_itemdb_read_groups_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_groups_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_read_groups_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_itemdb_read_chains(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_read_chains_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.read_chains();
	}
	if( HPMHooks.count.HP_itemdb_read_chains_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_chains_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_read_chains_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_itemdb_read_packages(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_read_packages_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.read_packages();
	}
	if( HPMHooks.count.HP_itemdb_read_packages_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_packages_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_read_packages_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_itemdb_write_cached_packages(const char *config_filename) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_write_cached_packages_pre ) {
		void (*preHookFunc) (const char **config_filename);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.write_cached_packages(config_filename);
	}
	if( HPMHooks.count.HP_itemdb_write_cached_packages_post ) {
		void (*postHookFunc) (const char *config_filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_write_cached_packages_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_write_cached_packages_post[hIndex].func;
			postHookFunc(config_filename);
		}
	}
	return;
}
bool HP_itemdb_read_cached_packages(const char *config_filename) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.read_cached_packages(config_filename);
	}
	if( HPMHooks.count.HP_itemdb_read_cached_packages_post ) {
		bool (*postHookFunc) (bool retVal___, const char *config_filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_cached_packages_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_read_cached_packages_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config_filename);
		}
	}
	return retVal___;
}
struct item_data* HP_itemdb_name2id(const char *str) {
	int hIndex = 0;
	struct item_data* retVal___ = NULL;
	if( HPMHooks.count.HP_itemdb_name2id_pre ) {
		struct item_data* (*preHookFunc) (const char **str);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.name2id(str);
	}
	if( HPMHooks.count.HP_itemdb_name2id_post ) {
		struct item_data* (*postHookFunc) (struct item_data* retVal___, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_name2id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_name2id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
struct item_data* HP_itemdb_search_name(const char *name) {
	int hIndex = 0;
	struct item_data* retVal___ = NULL;
	if( HPMHooks.count.HP_itemdb_search_name_pre ) {
		struct item_data* (*preHookFunc) (const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.search_name(name);
	}
	if( HPMHooks.count.HP_itemdb_search_name_post ) {
		struct item_data* (*postHookFunc) (struct item_data* retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_search_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
int HP_itemdb_search_name_array(struct item_data **data, int size, const char *str, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.search_name_array(data, size, str, flag);
	}
	if( HPMHooks.count.HP_itemdb_search_name_array_post ) {
		int (*postHookFunc) (int retVal___, struct item_data **data, int size, const char *str, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_name_array_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_search_name_array_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data, size, str, flag);
		}
	}
	return retVal___;
}
struct item_data* HP_itemdb_load(int nameid) {
	int hIndex = 0;
	struct item_data* retVal___ = NULL;
	if( HPMHooks.count.HP_itemdb_load_pre ) {
		struct item_data* (*preHookFunc) (int *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.load(nameid);
	}
	if( HPMHooks.count.HP_itemdb_load_post ) {
		struct item_data* (*postHookFunc) (struct item_data* retVal___, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_load_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_load_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid);
		}
	}
	return retVal___;
}
struct item_data* HP_itemdb_search(int nameid) {
	int hIndex = 0;
	struct item_data* retVal___ = NULL;
	if( HPMHooks.count.HP_itemdb_search_pre ) {
		struct item_data* (*preHookFunc) (int *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.search(nameid);
	}
	if( HPMHooks.count.HP_itemdb_search_post ) {
		struct item_data* (*postHookFunc) (struct item_data* retVal___, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid);
		}
	}
	return retVal___;
}
struct item_data* HP_itemdb_exists(int nameid) {
	int hIndex = 0;
	struct item_data* retVal___ = NULL;
	if( HPMHooks.count.HP_itemdb_exists_pre ) {
		struct item_data* (*preHookFunc) (int *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.exists(nameid);
	}
	if( HPMHooks.count.HP_itemdb_exists_post ) {
		struct item_data* (*postHookFunc) (struct item_data* retVal___, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_exists_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_exists_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid);
		}
	}
	return retVal___;
}
bool HP_itemdb_in_group(struct item_group *group, int nameid) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.in_group(group, nameid);
	}
	if( HPMHooks.count.HP_itemdb_in_group_post ) {
		bool (*postHookFunc) (bool retVal___, struct item_group *group, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_in_group_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_in_group_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group, nameid);
		}
	}
	return retVal___;
}
int HP_itemdb_group_item(struct item_group *group) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.group_item(group);
	}
	if( HPMHooks.count.HP_itemdb_group_item_post ) {
		int (*postHookFunc) (int retVal___, struct item_group *group);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_group_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_group_item_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group);
		}
	}
	return retVal___;
}
int HP_itemdb_chain_item(unsigned short chain_id, int *rate) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.chain_item(chain_id, rate);
	}
	if( HPMHooks.count.HP_itemdb_chain_item_post ) {
		int (*postHookFunc) (int retVal___, unsigned short chain_id, int *rate);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_chain_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_chain_item_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, chain_id, rate);
		}
	}
	return retVal___;
}
void HP_itemdb_package_item(struct map_session_data *sd, struct item_package *package) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_package_item_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct item_package **package);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.package_item(sd, package);
	}
	if( HPMHooks.count.HP_itemdb_package_item_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct item_package *package);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_package_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_package_item_post[hIndex].func;
			postHookFunc(sd, package);
		}
	}
	return;
}
int HP_itemdb_searchname_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_itemdb_searchname_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.itemdb.searchname_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_itemdb_searchname_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_itemdb_searchname_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_itemdb_searchname_array_sub(union DBKey key, struct DBData data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_itemdb_searchname_array_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.itemdb.searchname_array_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_itemdb_searchname_array_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchname_array_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_itemdb_searchname_array_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_itemdb_searchrandomid(struct item_group *group) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.searchrandomid(group);
	}
	if( HPMHooks.count.HP_itemdb_searchrandomid_post ) {
		int (*postHookFunc) (int retVal___, struct item_group *group);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_searchrandomid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_searchrandomid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group);
		}
	}
	return retVal___;
}
const char* HP_itemdb_typename(int type) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_itemdb_typename_pre ) {
		const char* (*preHookFunc) (int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.typename(type);
	}
	if( HPMHooks.count.HP_itemdb_typename_post ) {
		const char* (*postHookFunc) (const char* retVal___, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_typename_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_typename_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type);
		}
	}
	return retVal___;
}
void HP_itemdb_jobmask2mapid(uint64 *bclass, uint64 jobmask) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_jobmask2mapid_pre ) {
		void (*preHookFunc) (uint64 **bclass, uint64 *jobmask);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobmask2mapid_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_itemdb_jobmask2mapid_pre[hIndex].func;
			preHookFunc(&bclass, &jobmask);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.jobmask2mapid(bclass, jobmask);
	}
	if( HPMHooks.count.HP_itemdb_jobmask2mapid_post ) {
		void (*postHookFunc) (uint64 *bclass, uint64 jobmask);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobmask2mapid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_jobmask2mapid_post[hIndex].func;
			postHookFunc(bclass, jobmask);
		}
	}
	return;
}
void HP_itemdb_jobid2mapid(uint64 *bclass, int job_id, bool enable) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_jobid2mapid_pre ) {
		void (*preHookFunc) (uint64 **bclass, int *job_id, bool *enable);
		*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, &job_id, &enable);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.jobid2mapid(bclass, job_id, enable);
	}
	if( HPMHooks.count.HP_itemdb_jobid2mapid_post ) {
		void (*postHookFunc) (uint64 *bclass, int job_id, bool enable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_jobid2mapid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_jobid2mapid_post[hIndex].func;
			postHookFunc(bclass, job_id, enable);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.create_dummy_data();
	}
	if( HPMHooks.count.HP_itemdb_create_dummy_data_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_create_dummy_data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_create_dummy_data_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct item_data* HP_itemdb_create_item_data(int nameid) {
	int hIndex = 0;
	struct item_data* retVal___ = NULL;
	if( HPMHooks.count.HP_itemdb_create_item_data_pre ) {
		struct item_data* (*preHookFunc) (int *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.create_item_data(nameid);
	}
	if( HPMHooks.count.HP_itemdb_create_item_data_post ) {
		struct item_data* (*postHookFunc) (struct item_data* retVal___, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_create_item_data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_create_item_data_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid);
		}
	}
	return retVal___;
}
int HP_itemdb_isequip(int nameid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.isequip(nameid);
	}
	if( HPMHooks.count.HP_itemdb_isequip_post ) {
		int (*postHookFunc) (int retVal___, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_isequip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid);
		}
	}
	return retVal___;
}
int HP_itemdb_isequip2(struct item_data *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.isequip2(data);
	}
	if( HPMHooks.count.HP_itemdb_isequip2_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isequip2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_isequip2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
int HP_itemdb_isstackable(int nameid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.isstackable(nameid);
	}
	if( HPMHooks.count.HP_itemdb_isstackable_post ) {
		int (*postHookFunc) (int retVal___, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_isstackable_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid);
		}
	}
	return retVal___;
}
int HP_itemdb_isstackable2(struct item_data *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.isstackable2(data);
	}
	if( HPMHooks.count.HP_itemdb_isstackable2_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isstackable2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_isstackable2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
int HP_itemdb_isdropable_sub(struct item_data *item, int gmlv, int unused) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.isdropable_sub(item, gmlv, unused);
	}
	if( HPMHooks.count.HP_itemdb_isdropable_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isdropable_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_isdropable_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, unused);
		}
	}
	return retVal___;
}
int HP_itemdb_cantrade_sub(struct item_data *item, int gmlv, int gmlv2) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.cantrade_sub(item, gmlv, gmlv2);
	}
	if( HPMHooks.count.HP_itemdb_cantrade_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int gmlv2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cantrade_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_cantrade_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, gmlv2);
		}
	}
	return retVal___;
}
int HP_itemdb_canpartnertrade_sub(struct item_data *item, int gmlv, int gmlv2) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.canpartnertrade_sub(item, gmlv, gmlv2);
	}
	if( HPMHooks.count.HP_itemdb_canpartnertrade_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int gmlv2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canpartnertrade_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_canpartnertrade_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, gmlv2);
		}
	}
	return retVal___;
}
int HP_itemdb_cansell_sub(struct item_data *item, int gmlv, int unused) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.cansell_sub(item, gmlv, unused);
	}
	if( HPMHooks.count.HP_itemdb_cansell_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cansell_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_cansell_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, unused);
		}
	}
	return retVal___;
}
int HP_itemdb_cancartstore_sub(struct item_data *item, int gmlv, int unused) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.cancartstore_sub(item, gmlv, unused);
	}
	if( HPMHooks.count.HP_itemdb_cancartstore_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_cancartstore_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_cancartstore_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, unused);
		}
	}
	return retVal___;
}
int HP_itemdb_canstore_sub(struct item_data *item, int gmlv, int unused) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.canstore_sub(item, gmlv, unused);
	}
	if( HPMHooks.count.HP_itemdb_canstore_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canstore_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_canstore_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, unused);
		}
	}
	return retVal___;
}
int HP_itemdb_canguildstore_sub(struct item_data *item, int gmlv, int unused) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.canguildstore_sub(item, gmlv, unused);
	}
	if( HPMHooks.count.HP_itemdb_canguildstore_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canguildstore_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_canguildstore_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, unused);
		}
	}
	return retVal___;
}
int HP_itemdb_canmail_sub(struct item_data *item, int gmlv, int unused) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.canmail_sub(item, gmlv, unused);
	}
	if( HPMHooks.count.HP_itemdb_canmail_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canmail_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_canmail_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, unused);
		}
	}
	return retVal___;
}
int HP_itemdb_canauction_sub(struct item_data *item, int gmlv, int unused) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.canauction_sub(item, gmlv, unused);
	}
	if( HPMHooks.count.HP_itemdb_canauction_sub_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *item, int gmlv, int unused);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_canauction_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_canauction_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, unused);
		}
	}
	return retVal___;
}
int HP_itemdb_isrestricted(struct item *item, int gmlv, int gmlv2, int ( *func ) (struct item_data *, int, int)) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.isrestricted(item, gmlv, gmlv2, func);
	}
	if( HPMHooks.count.HP_itemdb_isrestricted_post ) {
		int (*postHookFunc) (int retVal___, struct item *item, int gmlv, int gmlv2, int ( *func ) (struct item_data *, int, int));
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isrestricted_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_isrestricted_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item, gmlv, gmlv2, func);
		}
	}
	return retVal___;
}
int HP_itemdb_isidentified(int nameid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.isidentified(nameid);
	}
	if( HPMHooks.count.HP_itemdb_isidentified_post ) {
		int (*postHookFunc) (int retVal___, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_isidentified_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid);
		}
	}
	return retVal___;
}
int HP_itemdb_isidentified2(struct item_data *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.isidentified2(data);
	}
	if( HPMHooks.count.HP_itemdb_isidentified2_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_isidentified2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_isidentified2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
int HP_itemdb_combo_split_atoi(char *str, int *val) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.combo_split_atoi(str, val);
	}
	if( HPMHooks.count.HP_itemdb_combo_split_atoi_post ) {
		int (*postHookFunc) (int retVal___, char *str, int *val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_combo_split_atoi_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_combo_split_atoi_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, val);
		}
	}
	return retVal___;
}
void HP_itemdb_read_combos(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_read_combos_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.read_combos();
	}
	if( HPMHooks.count.HP_itemdb_read_combos_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_combos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_read_combos_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_itemdb_gendercheck(struct item_data *id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.gendercheck(id);
	}
	if( HPMHooks.count.HP_itemdb_gendercheck_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_gendercheck_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_gendercheck_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
int HP_itemdb_validate_entry(struct item_data *entry, int n, const char *source) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.validate_entry(entry, n, source);
	}
	if( HPMHooks.count.HP_itemdb_validate_entry_post ) {
		int (*postHookFunc) (int retVal___, struct item_data *entry, int n, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_validate_entry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_validate_entry_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, entry, n, source);
		}
	}
	return retVal___;
}
void HP_itemdb_readdb_additional_fields(int itemid, struct config_setting_t *it, int n, const char *source) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_readdb_additional_fields_pre ) {
		void (*preHookFunc) (int *itemid, struct config_setting_t **it, int *n, const char **source);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_additional_fields_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_itemdb_readdb_additional_fields_pre[hIndex].func;
			preHookFunc(&itemid, &it, &n, &source);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.readdb_additional_fields(itemid, it, n, source);
	}
	if( HPMHooks.count.HP_itemdb_readdb_additional_fields_post ) {
		void (*postHookFunc) (int itemid, struct config_setting_t *it, int n, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_additional_fields_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_readdb_additional_fields_post[hIndex].func;
			postHookFunc(itemid, it, n, source);
		}
	}
	return;
}
void HP_itemdb_readdb_job_sub(struct item_data *id, struct config_setting_t *t) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_readdb_job_sub_pre ) {
		void (*preHookFunc) (struct item_data **id, struct config_setting_t **t);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_job_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_itemdb_readdb_job_sub_pre[hIndex].func;
			preHookFunc(&id, &t);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.readdb_job_sub(id, t);
	}
	if( HPMHooks.count.HP_itemdb_readdb_job_sub_post ) {
		void (*postHookFunc) (struct item_data *id, struct config_setting_t *t);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_job_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_readdb_job_sub_post[hIndex].func;
			postHookFunc(id, t);
		}
	}
	return;
}
int HP_itemdb_readdb_libconfig_sub(struct config_setting_t *it, int n, const char *source) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_itemdb_readdb_libconfig_sub_pre ) {
		int (*preHookFunc) (struct 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.readdb_libconfig_sub(it, n, source);
	}
	if( HPMHooks.count.HP_itemdb_readdb_libconfig_sub_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *it, int n, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_libconfig_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_readdb_libconfig_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, it, n, source);
		}
	}
	return retVal___;
}
int HP_itemdb_readdb_libconfig(const char *filename) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.readdb_libconfig(filename);
	}
	if( HPMHooks.count.HP_itemdb_readdb_libconfig_post ) {
		int (*postHookFunc) (int retVal___, const char *filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_readdb_libconfig_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_readdb_libconfig_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename);
		}
	}
	return retVal___;
}
uint64 HP_itemdb_unique_id(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.unique_id(sd);
	}
	if( HPMHooks.count.HP_itemdb_unique_id_post ) {
		uint64 (*postHookFunc) (uint64 retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_unique_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_unique_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.read(minimal);
	}
	if( HPMHooks.count.HP_itemdb_read_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_read_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
void HP_itemdb_destroy_item_data(struct item_data *self, int free_self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_itemdb_destroy_item_data_pre ) {
		void (*preHookFunc) (struct item_data **self, int *free_self);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.destroy_item_data(self, free_self);
	}
	if( HPMHooks.count.HP_itemdb_destroy_item_data_post ) {
		void (*postHookFunc) (struct item_data *self, int free_self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_destroy_item_data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_destroy_item_data_post[hIndex].func;
			postHookFunc(self, free_self);
		}
	}
	return;
}
int HP_itemdb_final_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_itemdb_final_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.itemdb.final_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_itemdb_final_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_final_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_itemdb_final_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.itemdb.clear(total);
	}
	if( HPMHooks.count.HP_itemdb_clear_post ) {
		void (*postHookFunc) (bool total);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_clear_post[hIndex].func;
			postHookFunc(total);
		}
	}
	return;
}
struct item_combo* HP_itemdb_id2combo(unsigned short id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.id2combo(id);
	}
	if( HPMHooks.count.HP_itemdb_id2combo_post ) {
		struct item_combo* (*postHookFunc) (struct item_combo* retVal___, unsigned short id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_id2combo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_id2combo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
bool HP_itemdb_is_item_usable(struct item_data *item) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_itemdb_is_item_usable_pre ) {
		bool (*preHookFunc) (struct item_data **item);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_is_item_usable_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_itemdb_is_item_usable_pre[hIndex].func;
			retVal___ = preHookFunc(&item);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.is_item_usable(item);
	}
	if( HPMHooks.count.HP_itemdb_is_item_usable_post ) {
		bool (*postHookFunc) (bool retVal___, struct item_data *item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_is_item_usable_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_is_item_usable_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item);
		}
	}
	return retVal___;
}
bool HP_itemdb_lookup_const(const struct config_setting_t *it, const char *name, int *value) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_itemdb_lookup_const_pre ) {
		bool (*preHookFunc) (const struct config_setting_t **it, const char **name, int **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_lookup_const_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_itemdb_lookup_const_pre[hIndex].func;
			retVal___ = preHookFunc(&it, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.itemdb.lookup_const(it, name, value);
	}
	if( HPMHooks.count.HP_itemdb_lookup_const_post ) {
		bool (*postHookFunc) (bool retVal___, const struct config_setting_t *it, const char *name, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_itemdb_lookup_const_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_itemdb_lookup_const_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, it, name, value);
		}
	}
	return retVal___;
}
/* libconfig_interface */
int HP_libconfig_read(struct config_t *config, FILE *stream) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_read_pre ) {
		int (*preHookFunc) (struct config_t **config, FILE **stream);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_read_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &stream);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.read(config, stream);
	}
	if( HPMHooks.count.HP_libconfig_read_post ) {
		int (*postHookFunc) (int retVal___, struct config_t *config, FILE *stream);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, stream);
		}
	}
	return retVal___;
}
void HP_libconfig_write(const struct config_t *config, FILE *stream) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_write_pre ) {
		void (*preHookFunc) (const struct config_t **config, FILE **stream);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_write_pre[hIndex].func;
			preHookFunc(&config, &stream);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.write(config, stream);
	}
	if( HPMHooks.count.HP_libconfig_write_post ) {
		void (*postHookFunc) (const struct config_t *config, FILE *stream);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_write_post[hIndex].func;
			postHookFunc(config, stream);
		}
	}
	return;
}
void HP_libconfig_set_options(struct config_t *config, int options) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_set_options_pre ) {
		void (*preHookFunc) (struct config_t **config, int *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_set_options_pre[hIndex].func;
			preHookFunc(&config, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.set_options(config, options);
	}
	if( HPMHooks.count.HP_libconfig_set_options_post ) {
		void (*postHookFunc) (struct config_t *config, int options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_options_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_set_options_post[hIndex].func;
			postHookFunc(config, options);
		}
	}
	return;
}
int HP_libconfig_get_options(const struct config_t *config) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_get_options_pre ) {
		int (*preHookFunc) (const struct config_t **config);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_options_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_get_options_pre[hIndex].func;
			retVal___ = preHookFunc(&config);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.get_options(config);
	}
	if( HPMHooks.count.HP_libconfig_get_options_post ) {
		int (*postHookFunc) (int retVal___, const struct config_t *config);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_get_options_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_get_options_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config);
		}
	}
	return retVal___;
}
int HP_libconfig_read_string(struct config_t *config, const char *str) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_read_string_pre ) {
		int (*preHookFunc) (struct config_t **config, const char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_read_string_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.read_string(config, str);
	}
	if( HPMHooks.count.HP_libconfig_read_string_post ) {
		int (*postHookFunc) (int retVal___, struct config_t *config, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_read_string_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, str);
		}
	}
	return retVal___;
}
int HP_libconfig_read_file_src(struct config_t *config, const char *filename) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_read_file_src_pre ) {
		int (*preHookFunc) (struct config_t **config, const char **filename);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_read_file_src_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &filename);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.read_file_src(config, filename);
	}
	if( HPMHooks.count.HP_libconfig_read_file_src_post ) {
		int (*postHookFunc) (int retVal___, struct config_t *config, const char *filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_read_file_src_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_read_file_src_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, filename);
		}
	}
	return retVal___;
}
int HP_libconfig_write_file(struct config_t *config, const char *filename) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_write_file_pre ) {
		int (*preHookFunc) (struct config_t **config, const char **filename);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_write_file_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &filename);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.write_file(config, filename);
	}
	if( HPMHooks.count.HP_libconfig_write_file_post ) {
		int (*postHookFunc) (int retVal___, struct config_t *config, const char *filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_write_file_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_write_file_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, filename);
		}
	}
	return retVal___;
}
void HP_libconfig_set_destructor(struct config_t *config, void ( *destructor ) (void *)) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_set_destructor_pre ) {
		void (*preHookFunc) (struct config_t **config, void ( **destructor ) (void *));
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_set_destructor_pre[hIndex].func;
			preHookFunc(&config, &destructor);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.set_destructor(config, destructor);
	}
	if( HPMHooks.count.HP_libconfig_set_destructor_post ) {
		void (*postHookFunc) (struct config_t *config, void ( *destructor ) (void *));
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_destructor_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_set_destructor_post[hIndex].func;
			postHookFunc(config, destructor);
		}
	}
	return;
}
void HP_libconfig_set_include_dir(struct config_t *config, const char *include_dir) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_set_include_dir_pre ) {
		void (*preHookFunc) (struct config_t **config, const char **include_dir);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_pre[hIndex].func;
			preHookFunc(&config, &include_dir);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.set_include_dir(config, include_dir);
	}
	if( HPMHooks.count.HP_libconfig_set_include_dir_post ) {
		void (*postHookFunc) (struct config_t *config, const char *include_dir);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_set_include_dir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_set_include_dir_post[hIndex].func;
			postHookFunc(config, include_dir);
		}
	}
	return;
}
void HP_libconfig_init(struct config_t *config) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_init_pre ) {
		void (*preHookFunc) (struct config_t **config);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_init_pre[hIndex].func;
			preHookFunc(&config);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.init(config);
	}
	if( HPMHooks.count.HP_libconfig_init_post ) {
		void (*postHookFunc) (struct config_t *config);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_init_post[hIndex].func;
			postHookFunc(config);
		}
	}
	return;
}
void HP_libconfig_destroy(struct config_t *config) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_destroy_pre ) {
		void (*preHookFunc) (struct config_t **config);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_destroy_pre[hIndex].func;
			preHookFunc(&config);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.destroy(config);
	}
	if( HPMHooks.count.HP_libconfig_destroy_post ) {
		void (*postHookFunc) (struct config_t *config);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_destroy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_destroy_post[hIndex].func;
			postHookFunc(config);
		}
	}
	return;
}
int HP_libconfig_setting_get_int(const struct config_setting_t *setting) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_int_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_int(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_int_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
long long HP_libconfig_setting_get_int64(const struct config_setting_t *setting) {
	int hIndex = 0;
	long long retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_int64_pre ) {
		long long (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_int64(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_int64_post ) {
		long long (*postHookFunc) (long long retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
double HP_libconfig_setting_get_float(const struct config_setting_t *setting) {
	int hIndex = 0;
	double retVal___ = 0.;
	if( HPMHooks.count.HP_libconfig_setting_get_float_pre ) {
		double (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_float(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_float_post ) {
		double (*postHookFunc) (double retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_get_bool(const struct config_setting_t *setting) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_bool_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_bool(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_bool_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
const char* HP_libconfig_setting_get_string(const struct config_setting_t *setting) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_get_string_pre ) {
		const char* (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_string(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_string_post ) {
		const char* (*postHookFunc) (const char* retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_lookup(struct config_setting_t *setting, const char *name) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_lookup_pre ) {
		struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, const char **name);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup(setting, name);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_int(const struct config_setting_t *setting, const char *name, int *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_int_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_int(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_int_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_int64(const struct config_setting_t *setting, const char *name, long long *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_int64_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, long long **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_int64(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_int64_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, long long *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int64_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int64_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_float(const struct config_setting_t *setting, const char *name, double *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_float_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, double **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_float(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_float_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, double *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_float_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_float_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_bool(const struct config_setting_t *setting, const char *name, int *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_bool_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_bool(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_bool_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_string(const struct config_setting_t *setting, const char *name, const char **value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_string_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, const char ***value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_string(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_string_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, const char **value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_string_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_set_int(struct config_setting_t *setting, int value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_set_int_pre ) {
		int (*preHookFunc) (struct config_setting_t **setting, int *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_int(setting, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_int_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_set_int64(struct config_setting_t *setting, long long value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_set_int64_pre ) {
		int (*preHookFunc) (struct config_setting_t **setting, long long *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_int64(setting, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_int64_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *setting, long long value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_set_float(struct config_setting_t *setting, double value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_set_float_pre ) {
		int (*preHookFunc) (struct config_setting_t **setting, double *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_float(setting, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_float_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *setting, double value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_set_bool(struct config_setting_t *setting, int value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_set_bool_pre ) {
		int (*preHookFunc) (struct config_setting_t **setting, int *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_bool(setting, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_bool_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *setting, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_set_string(struct config_setting_t *setting, const char *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_set_string_pre ) {
		int (*preHookFunc) (struct config_setting_t **setting, const char **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_string(setting, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_string_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *setting, const char *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_set_format(struct config_setting_t *setting, short format) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_set_format_pre ) {
		int (*preHookFunc) (struct config_setting_t **setting, short *format);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &format);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_format(setting, format);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_format_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *setting, short format);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_format_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_format_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, format);
		}
	}
	return retVal___;
}
short HP_libconfig_setting_get_format(const struct config_setting_t *setting) {
	int hIndex = 0;
	short retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_format_pre ) {
		short (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_format(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_format_post ) {
		short (*postHookFunc) (short retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_format_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_format_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_get_int_elem(const struct config_setting_t *setting, int idx) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_int_elem_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, int *idx);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_int_elem(setting, idx);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_int_elem_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx);
		}
	}
	return retVal___;
}
long long HP_libconfig_setting_get_int64_elem(const struct config_setting_t *setting, int idx) {
	int hIndex = 0;
	long long retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre ) {
		long long (*preHookFunc) (const struct config_setting_t **setting, int *idx);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_int64_elem(setting, idx);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_int64_elem_post ) {
		long long (*postHookFunc) (long long retVal___, const struct config_setting_t *setting, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int64_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int64_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx);
		}
	}
	return retVal___;
}
double HP_libconfig_setting_get_float_elem(const struct config_setting_t *setting, int idx) {
	int hIndex = 0;
	double retVal___ = 0.;
	if( HPMHooks.count.HP_libconfig_setting_get_float_elem_pre ) {
		double (*preHookFunc) (const struct config_setting_t **setting, int *idx);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_float_elem(setting, idx);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_float_elem_post ) {
		double (*postHookFunc) (double retVal___, const struct config_setting_t *setting, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_float_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_float_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_get_bool_elem(const struct config_setting_t *setting, int idx) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, int *idx);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_bool_elem(setting, idx);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_bool_elem_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx);
		}
	}
	return retVal___;
}
const char* HP_libconfig_setting_get_string_elem(const struct config_setting_t *setting, int idx) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_get_string_elem_pre ) {
		const char* (*preHookFunc) (const struct config_setting_t **setting, int *idx);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_string_elem(setting, idx);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_string_elem_post ) {
		const char* (*postHookFunc) (const char* retVal___, const struct config_setting_t *setting, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_string_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_string_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_set_int_elem(struct config_setting_t *setting, int idx, int value) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_set_int_elem_pre ) {
		struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, int *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_int_elem(setting, idx, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_int_elem_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx, value);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_set_int64_elem(struct config_setting_t *setting, int idx, long long value) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre ) {
		struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, long long *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_int64_elem(setting, idx, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_int64_elem_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, long long value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_int64_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_int64_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx, value);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_set_float_elem(struct config_setting_t *setting, int idx, double value) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_set_float_elem_pre ) {
		struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, double *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_float_elem(setting, idx, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_float_elem_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, double value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_float_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_float_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx, value);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_set_bool_elem(struct config_setting_t *setting, int idx, int value) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre ) {
		struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, int *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_bool_elem(setting, idx, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_bool_elem_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_bool_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_bool_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx, value);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_set_string_elem(struct config_setting_t *setting, int idx, const char *value) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_set_string_elem_pre ) {
		struct config_setting_t* (*preHookFunc) (struct config_setting_t **setting, int *idx, const char **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_set_string_elem(setting, idx, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_string_elem_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *setting, int idx, const char *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_string_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_string_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_index(const struct config_setting_t *setting) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_index_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_index_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_index(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_index_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_index_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_index_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_length(const struct config_setting_t *setting) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_length_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_length_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_length(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_length_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_length_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_length_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_get_elem(const struct config_setting_t *setting, unsigned int idx) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_get_elem_pre ) {
		struct config_setting_t* (*preHookFunc) (const struct config_setting_t **setting, unsigned int *idx);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_elem(setting, idx);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_elem_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, unsigned int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, idx);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_get_member(const struct config_setting_t *setting, const char *name) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_get_member_pre ) {
		struct config_setting_t* (*preHookFunc) (const struct config_setting_t **setting, const char **name);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_member(setting, name);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_member_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_setting_t *setting, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_member_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_member_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name);
		}
	}
	return retVal___;
}
struct config_setting_t* HP_libconfig_setting_add(struct config_setting_t *parent, const char *name, int type) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_setting_add_pre ) {
		struct config_setting_t* (*preHookFunc) (struct config_setting_t **parent, const char **name, int *type);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_add_pre[hIndex].func;
			retVal___ = preHookFunc(&parent, &name, &type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_add(parent, name, type);
	}
	if( HPMHooks.count.HP_libconfig_setting_add_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, struct config_setting_t *parent, const char *name, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_add_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, parent, name, type);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_remove(struct config_setting_t *parent, const char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_remove_pre ) {
		int (*preHookFunc) (struct config_setting_t **parent, const char **name);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_pre[hIndex].func;
			retVal___ = preHookFunc(&parent, &name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_remove(parent, name);
	}
	if( HPMHooks.count.HP_libconfig_setting_remove_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *parent, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, parent, name);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_remove_elem(struct config_setting_t *parent, unsigned int idx) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_remove_elem_pre ) {
		int (*preHookFunc) (struct config_setting_t **parent, unsigned int *idx);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_pre[hIndex].func;
			retVal___ = preHookFunc(&parent, &idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_remove_elem(parent, idx);
	}
	if( HPMHooks.count.HP_libconfig_setting_remove_elem_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *parent, unsigned int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_remove_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_remove_elem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, parent, idx);
		}
	}
	return retVal___;
}
void HP_libconfig_setting_set_hook(struct config_setting_t *setting, void *hook) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_setting_set_hook_pre ) {
		void (*preHookFunc) (struct config_setting_t **setting, void **hook);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_pre[hIndex].func;
			preHookFunc(&setting, &hook);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.setting_set_hook(setting, hook);
	}
	if( HPMHooks.count.HP_libconfig_setting_set_hook_post ) {
		void (*postHookFunc) (struct config_setting_t *setting, void *hook);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_set_hook_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_set_hook_post[hIndex].func;
			postHookFunc(setting, hook);
		}
	}
	return;
}
struct config_setting_t* HP_libconfig_lookup(const struct config_t *config, const char *filepath) {
	int hIndex = 0;
	struct config_setting_t* retVal___ = NULL;
	if( HPMHooks.count.HP_libconfig_lookup_pre ) {
		struct config_setting_t* (*preHookFunc) (const struct config_t **config, const char **filepath);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_lookup_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &filepath);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.lookup(config, filepath);
	}
	if( HPMHooks.count.HP_libconfig_lookup_post ) {
		struct config_setting_t* (*postHookFunc) (struct config_setting_t* retVal___, const struct config_t *config, const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_lookup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, filepath);
		}
	}
	return retVal___;
}
int HP_libconfig_lookup_int(const struct config_t *config, const char *filepath, int *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_lookup_int_pre ) {
		int (*preHookFunc) (const struct config_t **config, const char **filepath, int **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_lookup_int_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &filepath, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.lookup_int(config, filepath, value);
	}
	if( HPMHooks.count.HP_libconfig_lookup_int_post ) {
		int (*postHookFunc) (int retVal___, const struct config_t *config, const char *filepath, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_lookup_int_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, filepath, value);
		}
	}
	return retVal___;
}
int HP_libconfig_lookup_int64(const struct config_t *config, const char *filepath, long long *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_lookup_int64_pre ) {
		int (*preHookFunc) (const struct config_t **config, const char **filepath, long long **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &filepath, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.lookup_int64(config, filepath, value);
	}
	if( HPMHooks.count.HP_libconfig_lookup_int64_post ) {
		int (*postHookFunc) (int retVal___, const struct config_t *config, const char *filepath, long long *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_int64_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_lookup_int64_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, filepath, value);
		}
	}
	return retVal___;
}
int HP_libconfig_lookup_float(const struct config_t *config, const char *filepath, double *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_lookup_float_pre ) {
		int (*preHookFunc) (const struct config_t **config, const char **filepath, double **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_lookup_float_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &filepath, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.lookup_float(config, filepath, value);
	}
	if( HPMHooks.count.HP_libconfig_lookup_float_post ) {
		int (*postHookFunc) (int retVal___, const struct config_t *config, const char *filepath, double *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_float_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_lookup_float_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, filepath, value);
		}
	}
	return retVal___;
}
int HP_libconfig_lookup_bool(const struct config_t *config, const char *filepath, int *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_lookup_bool_pre ) {
		int (*preHookFunc) (const struct config_t **config, const char **filepath, int **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &filepath, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.lookup_bool(config, filepath, value);
	}
	if( HPMHooks.count.HP_libconfig_lookup_bool_post ) {
		int (*postHookFunc) (int retVal___, const struct config_t *config, const char *filepath, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_bool_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_lookup_bool_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, filepath, value);
		}
	}
	return retVal___;
}
int HP_libconfig_lookup_string(const struct config_t *config, const char *filepath, const char **value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_lookup_string_pre ) {
		int (*preHookFunc) (const struct config_t **config, const char **filepath, const char ***value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_lookup_string_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &filepath, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.lookup_string(config, filepath, value);
	}
	if( HPMHooks.count.HP_libconfig_lookup_string_post ) {
		int (*postHookFunc) (int retVal___, const struct config_t *config, const char *filepath, const char **value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_lookup_string_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, filepath, value);
		}
	}
	return retVal___;
}
int HP_libconfig_load_file(struct config_t *config, const char *config_filename) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_load_file_pre ) {
		int (*preHookFunc) (struct config_t **config, const char **config_filename);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_load_file_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_load_file_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &config_filename);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.load_file(config, config_filename);
	}
	if( HPMHooks.count.HP_libconfig_load_file_post ) {
		int (*postHookFunc) (int retVal___, struct config_t *config, const char *config_filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_load_file_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_load_file_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, config_filename);
		}
	}
	return retVal___;
}
void HP_libconfig_setting_copy_simple(struct config_setting_t *parent, const struct config_setting_t *src) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_setting_copy_simple_pre ) {
		void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_pre[hIndex].func;
			preHookFunc(&parent, &src);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.setting_copy_simple(parent, src);
	}
	if( HPMHooks.count.HP_libconfig_setting_copy_simple_post ) {
		void (*postHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_simple_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_simple_post[hIndex].func;
			postHookFunc(parent, src);
		}
	}
	return;
}
void HP_libconfig_setting_copy_elem(struct config_setting_t *parent, const struct config_setting_t *src) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_setting_copy_elem_pre ) {
		void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_pre[hIndex].func;
			preHookFunc(&parent, &src);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.setting_copy_elem(parent, src);
	}
	if( HPMHooks.count.HP_libconfig_setting_copy_elem_post ) {
		void (*postHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_elem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_elem_post[hIndex].func;
			postHookFunc(parent, src);
		}
	}
	return;
}
void HP_libconfig_setting_copy_aggregate(struct config_setting_t *parent, const struct config_setting_t *src) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre ) {
		void (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_pre[hIndex].func;
			preHookFunc(&parent, &src);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libconfig.setting_copy_aggregate(parent, src);
	}
	if( HPMHooks.count.HP_libconfig_setting_copy_aggregate_post ) {
		void (*postHookFunc) (struct config_setting_t *parent, const struct config_setting_t *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_aggregate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_aggregate_post[hIndex].func;
			postHookFunc(parent, src);
		}
	}
	return;
}
int HP_libconfig_setting_copy(struct config_setting_t *parent, const struct config_setting_t *src) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_copy_pre ) {
		int (*preHookFunc) (struct config_setting_t **parent, const struct config_setting_t **src);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_copy_pre[hIndex].func;
			retVal___ = preHookFunc(&parent, &src);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_copy(parent, src);
	}
	if( HPMHooks.count.HP_libconfig_setting_copy_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *parent, const struct config_setting_t *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_copy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_copy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, parent, src);
		}
	}
	return retVal___;
}
bool HP_libconfig_setting_get_bool_real(const struct config_setting_t *setting) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_libconfig_setting_get_bool_real_pre ) {
		bool (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_real_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_real_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_bool_real(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_bool_real_post ) {
		bool (*postHookFunc) (bool retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_bool_real_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_bool_real_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
uint32 HP_libconfig_setting_get_uint32(const struct config_setting_t *setting) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_uint32_pre ) {
		uint32 (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint32_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint32_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_uint32(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_uint32_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint32_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint32_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
uint16 HP_libconfig_setting_get_uint16(const struct config_setting_t *setting) {
	int hIndex = 0;
	uint16 retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_uint16_pre ) {
		uint16 (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint16_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint16_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_uint16(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_uint16_post ) {
		uint16 (*postHookFunc) (uint16 retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_uint16_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_uint16_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
int16 HP_libconfig_setting_get_int16(const struct config_setting_t *setting) {
	int hIndex = 0;
	int16 retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_get_int16_pre ) {
		int16 (*preHookFunc) (const struct config_setting_t **setting);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int16_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_get_int16_pre[hIndex].func;
			retVal___ = preHookFunc(&setting);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_get_int16(setting);
	}
	if( HPMHooks.count.HP_libconfig_setting_get_int16_post ) {
		int16 (*postHookFunc) (int16 retVal___, const struct config_setting_t *setting);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_get_int16_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_get_int16_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_bool_real(const struct config_setting_t *setting, const char *name, bool *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, bool **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_real_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_real_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_bool_real(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_bool_real_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, bool *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_bool_real_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_bool_real_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_uint32(const struct config_setting_t *setting, const char *name, uint32 *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint32 **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint32_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint32_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_uint32(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_uint32_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, uint32 *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint32_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint32_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_uint16(const struct config_setting_t *setting, const char *name, uint16 *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, uint16 **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint16_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint16_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_uint16(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_uint16_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, uint16 *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_uint16_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_uint16_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_int16(const struct config_setting_t *setting, const char *name, int16 *value) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_int16_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, int16 **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int16_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int16_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_int16(setting, name, value);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_int16_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, int16 *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_int16_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_int16_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, value);
		}
	}
	return retVal___;
}
int HP_libconfig_setting_lookup_mutable_string(const struct config_setting_t *setting, const char *name, char *out, size_t out_size) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre ) {
		int (*preHookFunc) (const struct config_setting_t **setting, const char **name, char **out, size_t *out_size);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_pre[hIndex].func;
			retVal___ = preHookFunc(&setting, &name, &out, &out_size);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.setting_lookup_mutable_string(setting, name, out, out_size);
	}
	if( HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post ) {
		int (*postHookFunc) (int retVal___, const struct config_setting_t *setting, const char *name, char *out, size_t out_size);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_setting_lookup_mutable_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_setting_lookup_mutable_string_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, setting, name, out, out_size);
		}
	}
	return retVal___;
}
int HP_libconfig_lookup_mutable_string(const struct config_t *config, const char *name, char *out, size_t out_size) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libconfig_lookup_mutable_string_pre ) {
		int (*preHookFunc) (const struct config_t **config, const char **name, char **out, size_t *out_size);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_pre[hIndex].func;
			retVal___ = preHookFunc(&config, &name, &out, &out_size);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libconfig.lookup_mutable_string(config, name, out, out_size);
	}
	if( HPMHooks.count.HP_libconfig_lookup_mutable_string_post ) {
		int (*postHookFunc) (int retVal___, const struct config_t *config, const char *name, char *out, size_t out_size);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libconfig_lookup_mutable_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libconfig_lookup_mutable_string_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, config, name, out, out_size);
		}
	}
	return retVal___;
}
/* log_interface */
void HP_logs_pick_pc(struct map_session_data *sd, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_pick_pc_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.pick_pc(sd, type, amount, itm, data);
	}
	if( HPMHooks.count.HP_logs_pick_pc_post ) {
		void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type type, int amount, struct item *itm, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_pc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_pick_pc_post[hIndex].func;
			postHookFunc(sd, type, amount, itm, data);
		}
	}
	return;
}
void HP_logs_pick_mob(struct mob_data *md, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_pick_mob_pre ) {
		void (*preHookFunc) (struct mob_data **md, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.pick_mob(md, type, amount, itm, data);
	}
	if( HPMHooks.count.HP_logs_pick_mob_post ) {
		void (*postHookFunc) (struct mob_data *md, e_log_pick_type type, int amount, struct item *itm, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_mob_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_pick_mob_post[hIndex].func;
			postHookFunc(md, type, amount, itm, data);
		}
	}
	return;
}
void HP_logs_zeny(struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_zeny_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, e_log_pick_type *type, struct map_session_data **src_sd, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.zeny(sd, type, src_sd, amount);
	}
	if( HPMHooks.count.HP_logs_zeny_post ) {
		void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_zeny_post[hIndex].func;
			postHookFunc(sd, type, src_sd, amount);
		}
	}
	return;
}
void HP_logs_npc(struct map_session_data *sd, const char *message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_npc_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **message);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.npc(sd, message);
	}
	if( HPMHooks.count.HP_logs_npc_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_npc_post[hIndex].func;
			postHookFunc(sd, message);
		}
	}
	return;
}
void HP_logs_chat(e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_chat_pre ) {
		void (*preHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char **mapname, int *x, int *y, const char **dst_charname, const char **message);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.chat(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message);
	}
	if( HPMHooks.count.HP_logs_chat_post ) {
		void (*postHookFunc) (e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_chat_post[hIndex].func;
			postHookFunc(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message);
		}
	}
	return;
}
void HP_logs_atcommand(struct map_session_data *sd, const char *message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_atcommand_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **message);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.atcommand(sd, message);
	}
	if( HPMHooks.count.HP_logs_atcommand_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_atcommand_post[hIndex].func;
			postHookFunc(sd, message);
		}
	}
	return;
}
void HP_logs_branch(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_branch_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.branch(sd);
	}
	if( HPMHooks.count.HP_logs_branch_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_branch_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_logs_mvpdrop(struct map_session_data *sd, int monster_id, int *log_mvp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_mvpdrop_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *monster_id, int **log_mvp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.mvpdrop(sd, monster_id, log_mvp);
	}
	if( HPMHooks.count.HP_logs_mvpdrop_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int monster_id, int *log_mvp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_mvpdrop_post[hIndex].func;
			postHookFunc(sd, monster_id, log_mvp);
		}
	}
	return;
}
void HP_logs_pick_sub(int id, int16 m, e_log_pick_type type, int amount, struct item *itm, struct item_data *data) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_pick_sub_pre ) {
		void (*preHookFunc) (int *id, int16 *m, e_log_pick_type *type, int *amount, struct item **itm, struct item_data **data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.pick_sub(id, m, type, amount, itm, data);
	}
	if( HPMHooks.count.HP_logs_pick_sub_post ) {
		void (*postHookFunc) (int id, int16 m, e_log_pick_type type, int amount, struct item *itm, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_pick_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_pick_sub_post[hIndex].func;
			postHookFunc(id, m, type, amount, itm, data);
		}
	}
	return;
}
void HP_logs_zeny_sub(struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_zeny_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, e_log_pick_type *type, struct map_session_data **src_sd, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.zeny_sub(sd, type, src_sd, amount);
	}
	if( HPMHooks.count.HP_logs_zeny_sub_post ) {
		void (*postHookFunc) (struct map_session_data *sd, e_log_pick_type type, struct map_session_data *src_sd, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_zeny_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_zeny_sub_post[hIndex].func;
			postHookFunc(sd, type, src_sd, amount);
		}
	}
	return;
}
void HP_logs_npc_sub(struct map_session_data *sd, const char *message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_npc_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **message);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.npc_sub(sd, message);
	}
	if( HPMHooks.count.HP_logs_npc_sub_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_npc_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_npc_sub_post[hIndex].func;
			postHookFunc(sd, message);
		}
	}
	return;
}
void HP_logs_chat_sub(e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_chat_sub_pre ) {
		void (*preHookFunc) (e_log_chat_type *type, int *type_id, int *src_charid, int *src_accid, const char **mapname, int *x, int *y, const char **dst_charname, const char **message);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.chat_sub(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message);
	}
	if( HPMHooks.count.HP_logs_chat_sub_post ) {
		void (*postHookFunc) (e_log_chat_type type, int type_id, int src_charid, int src_accid, const char *mapname, int x, int y, const char *dst_charname, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chat_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_chat_sub_post[hIndex].func;
			postHookFunc(type, type_id, src_charid, src_accid, mapname, x, y, dst_charname, message);
		}
	}
	return;
}
void HP_logs_atcommand_sub(struct map_session_data *sd, const char *message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_atcommand_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **message);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.atcommand_sub(sd, message);
	}
	if( HPMHooks.count.HP_logs_atcommand_sub_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_atcommand_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_atcommand_sub_post[hIndex].func;
			postHookFunc(sd, message);
		}
	}
	return;
}
void HP_logs_branch_sub(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_branch_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.branch_sub(sd);
	}
	if( HPMHooks.count.HP_logs_branch_sub_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_branch_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_branch_sub_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_logs_mvpdrop_sub(struct map_session_data *sd, int monster_id, int *log_mvp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_mvpdrop_sub_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *monster_id, int **log_mvp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.mvpdrop_sub(sd, monster_id, log_mvp);
	}
	if( HPMHooks.count.HP_logs_mvpdrop_sub_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int monster_id, int *log_mvp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_mvpdrop_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_mvpdrop_sub_post[hIndex].func;
			postHookFunc(sd, monster_id, log_mvp);
		}
	}
	return;
}
bool HP_logs_config_read(const char *filename, bool imported) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_logs_config_read_pre ) {
		bool (*preHookFunc) (const char **filename, bool *imported);
		*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(&filename, &imported);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.logs.config_read(filename, imported);
	}
	if( HPMHooks.count.HP_logs_config_read_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename, bool imported);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_config_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, imported);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.config_done();
	}
	if( HPMHooks.count.HP_logs_config_done_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_config_done_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_config_done_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_logs_sql_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_sql_init_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.sql_init();
	}
	if( HPMHooks.count.HP_logs_sql_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_sql_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_sql_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_logs_sql_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_logs_sql_final_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.logs.sql_final();
	}
	if( HPMHooks.count.HP_logs_sql_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_sql_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_sql_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
char HP_logs_picktype2char(e_log_pick_type type) {
	int hIndex = 0;
	char retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.logs.picktype2char(type);
	}
	if( HPMHooks.count.HP_logs_picktype2char_post ) {
		char (*postHookFunc) (char retVal___, e_log_pick_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_picktype2char_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_picktype2char_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type);
		}
	}
	return retVal___;
}
char HP_logs_chattype2char(e_log_chat_type type) {
	int hIndex = 0;
	char retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.logs.chattype2char(type);
	}
	if( HPMHooks.count.HP_logs_chattype2char_post ) {
		char (*postHookFunc) (char retVal___, e_log_chat_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_chattype2char_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_chattype2char_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type);
		}
	}
	return retVal___;
}
bool HP_logs_should_log_item(int nameid, int amount, int refine, struct item_data *id) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.logs.should_log_item(nameid, amount, refine, id);
	}
	if( HPMHooks.count.HP_logs_should_log_item_post ) {
		bool (*postHookFunc) (bool retVal___, int nameid, int amount, int refine, struct item_data *id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_logs_should_log_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_logs_should_log_item_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid, amount, refine, id);
		}
	}
	return retVal___;
}
/* mail_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mail.clear(sd);
	}
	if( HPMHooks.count.HP_mail_clear_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_clear_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_mail_removeitem(struct map_session_data *sd, short flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mail.removeitem(sd, flag);
	}
	if( HPMHooks.count.HP_mail_removeitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, short flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removeitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_removeitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, flag);
		}
	}
	return retVal___;
}
int HP_mail_removezeny(struct map_session_data *sd, short flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mail.removezeny(sd, flag);
	}
	if( HPMHooks.count.HP_mail_removezeny_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, short flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_removezeny_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_removezeny_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, flag);
		}
	}
	return retVal___;
}
unsigned char HP_mail_setitem(struct map_session_data *sd, int idx, int amount) {
	int hIndex = 0;
	unsigned char retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mail.setitem(sd, idx, amount);
	}
	if( HPMHooks.count.HP_mail_setitem_post ) {
		unsigned char (*postHookFunc) (unsigned char retVal___, struct map_session_data *sd, int idx, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_setitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, idx, amount);
		}
	}
	return retVal___;
}
bool HP_mail_setattachment(struct map_session_data *sd, struct mail_message *msg) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mail.setattachment(sd, msg);
	}
	if( HPMHooks.count.HP_mail_setattachment_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct mail_message *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_setattachment_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_setattachment_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, msg);
		}
	}
	return retVal___;
}
void HP_mail_getattachment(struct map_session_data *sd, int zeny, struct item *item) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mail_getattachment_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *zeny, struct item **item);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mail.getattachment(sd, zeny, item);
	}
	if( HPMHooks.count.HP_mail_getattachment_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int zeny, struct item *item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_getattachment_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_getattachment_post[hIndex].func;
			postHookFunc(sd, zeny, item);
		}
	}
	return;
}
int HP_mail_openmail(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mail.openmail(sd);
	}
	if( HPMHooks.count.HP_mail_openmail_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_openmail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_openmail_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_mail_deliveryfail(struct map_session_data *sd, struct mail_message *msg) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mail_deliveryfail_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct mail_message **msg);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mail.deliveryfail(sd, msg);
	}
	if( HPMHooks.count.HP_mail_deliveryfail_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct mail_message *msg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_deliveryfail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_deliveryfail_post[hIndex].func;
			postHookFunc(sd, msg);
		}
	}
	return;
}
bool HP_mail_invalid_operation(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mail.invalid_operation(sd);
	}
	if( HPMHooks.count.HP_mail_invalid_operation_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mail_invalid_operation_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mail_invalid_operation_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
/* malloc_interface */
void HP_iMalloc_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_iMalloc_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.iMalloc.init();
	}
	if( HPMHooks.count.HP_iMalloc_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_iMalloc_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_iMalloc_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.iMalloc.final();
	}
	if( HPMHooks.count.HP_iMalloc_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void* HP_iMalloc_malloc(size_t size, const char *file, int line, const char *func) {
	int hIndex = 0;
	void* retVal___ = NULL;
	if( HPMHooks.count.HP_iMalloc_malloc_pre ) {
		void* (*preHookFunc) (size_t *size, const char **file, int *line, const char **func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_malloc_pre[hIndex].func;
			retVal___ = preHookFunc(&size, &file, &line, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.iMalloc.malloc(size, file, line, func);
	}
	if( HPMHooks.count.HP_iMalloc_malloc_post ) {
		void* (*postHookFunc) (void* retVal___, size_t size, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_malloc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_malloc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, size, file, line, func);
		}
	}
	return retVal___;
}
void* HP_iMalloc_calloc(size_t num, size_t size, const char *file, int line, const char *func) {
	int hIndex = 0;
	void* retVal___ = NULL;
	if( HPMHooks.count.HP_iMalloc_calloc_pre ) {
		void* (*preHookFunc) (size_t *num, size_t *size, const char **file, int *line, const char **func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_calloc_pre[hIndex].func;
			retVal___ = preHookFunc(&num, &size, &file, &line, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.iMalloc.calloc(num, size, file, line, func);
	}
	if( HPMHooks.count.HP_iMalloc_calloc_post ) {
		void* (*postHookFunc) (void* retVal___, size_t num, size_t size, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_calloc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_calloc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, num, size, file, line, func);
		}
	}
	return retVal___;
}
void* HP_iMalloc_realloc(void *p, size_t size, const char *file, int line, const char *func) {
	int hIndex = 0;
	void* retVal___ = NULL;
	if( HPMHooks.count.HP_iMalloc_realloc_pre ) {
		void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_realloc_pre[hIndex].func;
			retVal___ = preHookFunc(&p, &size, &file, &line, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.iMalloc.realloc(p, size, file, line, func);
	}
	if( HPMHooks.count.HP_iMalloc_realloc_post ) {
		void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_realloc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_realloc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, size, file, line, func);
		}
	}
	return retVal___;
}
void* HP_iMalloc_reallocz(void *p, size_t size, const char *file, int line, const char *func) {
	int hIndex = 0;
	void* retVal___ = NULL;
	if( HPMHooks.count.HP_iMalloc_reallocz_pre ) {
		void* (*preHookFunc) (void **p, size_t *size, const char **file, int *line, const char **func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_reallocz_pre[hIndex].func;
			retVal___ = preHookFunc(&p, &size, &file, &line, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.iMalloc.reallocz(p, size, file, line, func);
	}
	if( HPMHooks.count.HP_iMalloc_reallocz_post ) {
		void* (*postHookFunc) (void* retVal___, void *p, size_t size, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_reallocz_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_reallocz_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, size, file, line, func);
		}
	}
	return retVal___;
}
char* HP_iMalloc_astrdup(const char *p, const char *file, int line, const char *func) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_iMalloc_astrdup_pre ) {
		char* (*preHookFunc) (const char **p, const char **file, int *line, const char **func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_astrdup_pre[hIndex].func;
			retVal___ = preHookFunc(&p, &file, &line, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.iMalloc.astrdup(p, file, line, func);
	}
	if( HPMHooks.count.HP_iMalloc_astrdup_post ) {
		char* (*postHookFunc) (char* retVal___, const char *p, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrdup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_astrdup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, file, line, func);
		}
	}
	return retVal___;
}
char* HP_iMalloc_astrndup(const char *p, size_t size, const char *file, int line, const char *func) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_iMalloc_astrndup_pre ) {
		char* (*preHookFunc) (const char **p, size_t *size, const char **file, int *line, const char **func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_astrndup_pre[hIndex].func;
			retVal___ = preHookFunc(&p, &size, &file, &line, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.iMalloc.astrndup(p, size, file, line, func);
	}
	if( HPMHooks.count.HP_iMalloc_astrndup_post ) {
		char* (*postHookFunc) (char* retVal___, const char *p, size_t size, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_astrndup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_astrndup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, size, file, line, func);
		}
	}
	return retVal___;
}
void HP_iMalloc_free(void *p, const char *file, int line, const char *func) {
	int hIndex = 0;
	if( HPMHooks.count.HP_iMalloc_free_pre ) {
		void (*preHookFunc) (void **p, const char **file, int *line, const char **func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_free_pre[hIndex].func;
			preHookFunc(&p, &file, &line, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.iMalloc.free(p, file, line, func);
	}
	if( HPMHooks.count.HP_iMalloc_free_post ) {
		void (*postHookFunc) (void *p, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_free_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_free_post[hIndex].func;
			postHookFunc(p, file, line, func);
		}
	}
	return;
}
void HP_iMalloc_memory_check(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_iMalloc_memory_check_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_memory_check_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.iMalloc.memory_check();
	}
	if( HPMHooks.count.HP_iMalloc_memory_check_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_memory_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_memory_check_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_iMalloc_verify_ptr(void *ptr) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_iMalloc_verify_ptr_pre ) {
		bool (*preHookFunc) (void **ptr);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_pre[hIndex].func;
			retVal___ = preHookFunc(&ptr);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.iMalloc.verify_ptr(ptr);
	}
	if( HPMHooks.count.HP_iMalloc_verify_ptr_post ) {
		bool (*postHookFunc) (bool retVal___, void *ptr);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_verify_ptr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_verify_ptr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ptr);
		}
	}
	return retVal___;
}
size_t HP_iMalloc_usage(void) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_iMalloc_usage_pre ) {
		size_t (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_usage_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.iMalloc.usage();
	}
	if( HPMHooks.count.HP_iMalloc_usage_post ) {
		size_t (*postHookFunc) (size_t retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_usage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_usage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_iMalloc_post_shutdown(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_iMalloc_post_shutdown_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.iMalloc.post_shutdown();
	}
	if( HPMHooks.count.HP_iMalloc_post_shutdown_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_post_shutdown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_post_shutdown_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_iMalloc_init_messages(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_iMalloc_init_messages_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_iMalloc_init_messages_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.iMalloc.init_messages();
	}
	if( HPMHooks.count.HP_iMalloc_init_messages_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_iMalloc_init_messages_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_iMalloc_init_messages_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* map_interface */
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.zone_init();
	}
	if( HPMHooks.count.HP_map_zone_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_map_zone_remove(int m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_zone_remove_pre ) {
		void (*preHookFunc) (int *m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.zone_remove(m);
	}
	if( HPMHooks.count.HP_map_zone_remove_post ) {
		void (*postHookFunc) (int m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_remove_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_map_zone_apply(int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_zone_apply_pre ) {
		void (*preHookFunc) (int *m, struct map_zone_data **zone, const char **start, const char **buffer, const char **filepath);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.zone_apply(m, zone, start, buffer, filepath);
	}
	if( HPMHooks.count.HP_map_zone_apply_post ) {
		void (*postHookFunc) (int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_apply_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_apply_post[hIndex].func;
			postHookFunc(m, zone, start, buffer, filepath);
		}
	}
	return;
}
void HP_map_zone_change(int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_zone_change_pre ) {
		void (*preHookFunc) (int *m, struct map_zone_data **zone, const char **start, const char **buffer, const char **filepath);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.zone_change(m, zone, start, buffer, filepath);
	}
	if( HPMHooks.count.HP_map_zone_change_post ) {
		void (*postHookFunc) (int m, struct map_zone_data *zone, const char *start, const char *buffer, const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_change_post[hIndex].func;
			postHookFunc(m, zone, start, buffer, filepath);
		}
	}
	return;
}
void HP_map_zone_change2(int m, struct map_zone_data *zone) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_zone_change2_pre ) {
		void (*preHookFunc) (int *m, struct map_zone_data **zone);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.zone_change2(m, zone);
	}
	if( HPMHooks.count.HP_map_zone_change2_post ) {
		void (*postHookFunc) (int m, struct map_zone_data *zone);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_change2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_change2_post[hIndex].func;
			postHookFunc(m, zone);
		}
	}
	return;
}
int HP_map_getcell(int16 m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_getcell_pre ) {
		int (*preHookFunc) (int16 *m, const struct block_list **bl, 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, &bl, &x, &y, &cellchk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.getcell(m, bl, x, y, cellchk);
	}
	if( HPMHooks.count.HP_map_getcell_post ) {
		int (*postHookFunc) (int retVal___, int16 m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_getcell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, bl, x, y, cellchk);
		}
	}
	return retVal___;
}
void HP_map_setgatcell(int16 m, int16 x, int16 y, int gat) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_setgatcell_pre ) {
		void (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *gat);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.setgatcell(m, x, y, gat);
	}
	if( HPMHooks.count.HP_map_setgatcell_post ) {
		void (*postHookFunc) (int16 m, int16 x, int16 y, int gat);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setgatcell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_setgatcell_post[hIndex].func;
			postHookFunc(m, x, y, gat);
		}
	}
	return;
}
void HP_map_cellfromcache(struct map_data *m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_cellfromcache_pre ) {
		void (*preHookFunc) (struct map_data **m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.cellfromcache(m);
	}
	if( HPMHooks.count.HP_map_cellfromcache_post ) {
		void (*postHookFunc) (struct map_data *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cellfromcache_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_cellfromcache_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_map_setusers(int p1) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_setusers_pre ) {
		void (*preHookFunc) (int *p1);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.setusers(p1);
	}
	if( HPMHooks.count.HP_map_setusers_post ) {
		void (*postHookFunc) (int p1);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setusers_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_setusers_post[hIndex].func;
			postHookFunc(p1);
		}
	}
	return;
}
int HP_map_getusers(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.getusers();
	}
	if( HPMHooks.count.HP_map_getusers_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getusers_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_getusers_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_map_usercount(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.usercount();
	}
	if( HPMHooks.count.HP_map_usercount_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_usercount_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_usercount_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_map_freeblock(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.freeblock(bl);
	}
	if( HPMHooks.count.HP_map_freeblock_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_freeblock_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_map_freeblock_lock(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.freeblock_lock();
	}
	if( HPMHooks.count.HP_map_freeblock_lock_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_lock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_freeblock_lock_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_map_freeblock_unlock(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.freeblock_unlock();
	}
	if( HPMHooks.count.HP_map_freeblock_unlock_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_unlock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_freeblock_unlock_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_map_addblock(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.addblock(bl);
	}
	if( HPMHooks.count.HP_map_addblock_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addblock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_addblock_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_map_delblock(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.delblock(bl);
	}
	if( HPMHooks.count.HP_map_delblock_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delblock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_delblock_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_map_moveblock(struct block_list *bl, int x1, int y1, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.moveblock(bl, x1, y1, tick);
	}
	if( HPMHooks.count.HP_map_moveblock_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int x1, int y1, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_moveblock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_moveblock_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, x1, y1, tick);
		}
	}
	return retVal___;
}
int HP_map_count_oncell(int16 m, int16 x, int16 y, int type, int flag) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_count_oncell_pre ) {
		int (*preHookFunc) (int16 *m, int16 *x, int16 *y, int *type, int *flag);
		*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, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.count_oncell(m, x, y, type, flag);
	}
	if( HPMHooks.count.HP_map_count_oncell_post ) {
		int (*postHookFunc) (int retVal___, int16 m, int16 x, int16 y, int type, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_count_oncell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_count_oncell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, x, y, type, flag);
		}
	}
	return retVal___;
}
struct skill_unit* HP_map_find_skill_unit_oncell(struct block_list *target, int16 x, int16 y, uint16 skill_id, struct skill_unit *out_unit, int flag) {
	int hIndex = 0;
	struct skill_unit* retVal___ = NULL;
	if( HPMHooks.count.HP_map_find_skill_unit_oncell_pre ) {
		struct skill_unit* (*preHookFunc) (struct block_list **target, int16 *x, int16 *y, uint16 *skill_id, struct skill_unit **out_unit, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.find_skill_unit_oncell(target, x, y, skill_id, out_unit, flag);
	}
	if( HPMHooks.count.HP_map_find_skill_unit_oncell_post ) {
		struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, struct block_list *target, int16 x, int16 y, uint16 skill_id, struct skill_unit *out_unit, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_find_skill_unit_oncell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_find_skill_unit_oncell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, target, x, y, skill_id, out_unit, flag);
		}
	}
	return retVal___;
}
int HP_map_get_new_object_id(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.get_new_object_id();
	}
	if( HPMHooks.count.HP_map_get_new_object_id_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_get_new_object_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_get_new_object_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_map_search_freecell(struct block_list *src, int16 m, int16 *x, int16 *y, int16 rx, int16 ry, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.search_freecell(src, m, x, y, rx, ry, flag);
	}
	if( HPMHooks.count.HP_map_search_freecell_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, int16 m, int16 *x, int16 *y, int16 rx, int16 ry, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_search_freecell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_search_freecell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, m, x, y, rx, ry, flag);
		}
	}
	return retVal___;
}
bool HP_map_closest_freecell(int16 m, const struct block_list *bl, int16 *x, int16 *y, int type, int flag) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_map_closest_freecell_pre ) {
		bool (*preHookFunc) (int16 *m, const struct block_list **bl, int16 **x, int16 **y, int *type, int *flag);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_closest_freecell_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_closest_freecell_pre[hIndex].func;
			retVal___ = preHookFunc(&m, &bl, &x, &y, &type, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.closest_freecell(m, bl, x, y, type, flag);
	}
	if( HPMHooks.count.HP_map_closest_freecell_post ) {
		bool (*postHookFunc) (bool retVal___, int16 m, const struct block_list *bl, int16 *x, int16 *y, int type, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_closest_freecell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_closest_freecell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, bl, x, y, type, flag);
		}
	}
	return retVal___;
}
int HP_map_quit(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.quit(sd);
	}
	if( HPMHooks.count.HP_map_quit_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_quit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_quit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
bool HP_map_addnpc(int16 m, struct npc_data *nd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.addnpc(m, nd);
	}
	if( HPMHooks.count.HP_map_addnpc_post ) {
		bool (*postHookFunc) (bool retVal___, int16 m, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_addnpc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, nd);
		}
	}
	return retVal___;
}
int HP_map_clearflooritem_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.clearflooritem_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_map_clearflooritem_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_clearflooritem_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_map_removemobs_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.removemobs_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_map_removemobs_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_removemobs_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_map_clearflooritem(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_clearflooritem_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.clearflooritem(bl);
	}
	if( HPMHooks.count.HP_map_clearflooritem_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clearflooritem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_clearflooritem_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
int HP_map_addflooritem(const struct block_list *bl, struct item *item_data, int amount, int16 m, int16 x, int16 y, int first_charid, int second_charid, int third_charid, int flags) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_addflooritem_pre ) {
		int (*preHookFunc) (const struct block_list **bl, 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(&bl, &item_data, &amount, &m, &x, &y, &first_charid, &second_charid, &third_charid, &flags);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.addflooritem(bl, item_data, amount, m, x, y, first_charid, second_charid, third_charid, flags);
	}
	if( HPMHooks.count.HP_map_addflooritem_post ) {
		int (*postHookFunc) (int retVal___, const struct block_list *bl, struct item *item_data, int amount, int16 m, int16 x, int16 y, int first_charid, int second_charid, int third_charid, int flags);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addflooritem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_addflooritem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, item_data, amount, m, x, y, first_charid, second_charid, third_charid, flags);
		}
	}
	return retVal___;
}
void HP_map_addnickdb(int charid, const char *nick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_addnickdb_pre ) {
		void (*preHookFunc) (int *charid, const char **nick);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.addnickdb(charid, nick);
	}
	if( HPMHooks.count.HP_map_addnickdb_post ) {
		void (*postHookFunc) (int charid, const char *nick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addnickdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_addnickdb_post[hIndex].func;
			postHookFunc(charid, nick);
		}
	}
	return;
}
void HP_map_delnickdb(int charid, const char *nick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_delnickdb_pre ) {
		void (*preHookFunc) (int *charid, const char **nick);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.delnickdb(charid, nick);
	}
	if( HPMHooks.count.HP_map_delnickdb_post ) {
		void (*postHookFunc) (int charid, const char *nick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delnickdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_delnickdb_post[hIndex].func;
			postHookFunc(charid, nick);
		}
	}
	return;
}
void HP_map_reqnickdb(struct map_session_data *sd, int charid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_reqnickdb_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *charid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.reqnickdb(sd, charid);
	}
	if( HPMHooks.count.HP_map_reqnickdb_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int charid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reqnickdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_reqnickdb_post[hIndex].func;
			postHookFunc(sd, charid);
		}
	}
	return;
}
const char* HP_map_charid2nick(int charid) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_map_charid2nick_pre ) {
		const char* (*preHookFunc) (int *charid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.charid2nick(charid);
	}
	if( HPMHooks.count.HP_map_charid2nick_post ) {
		const char* (*postHookFunc) (const char* retVal___, int charid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2nick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_charid2nick_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, charid);
		}
	}
	return retVal___;
}
struct map_session_data* HP_map_charid2sd(int charid) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_charid2sd_pre ) {
		struct map_session_data* (*preHookFunc) (int *charid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.charid2sd(charid);
	}
	if( HPMHooks.count.HP_map_charid2sd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int charid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_charid2sd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_charid2sd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, charid);
		}
	}
	return retVal___;
}
void HP_map_vforeachpc(int ( *func ) (struct map_session_data *sd, va_list args), va_list args) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_vforeachpc_pre ) {
		void (*preHookFunc) (int ( **func ) (struct map_session_data *sd, va_list args), va_list args);
		*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;
			preHookFunc(&func, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		HPMHooks.source.map.vforeachpc(func, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_vforeachpc_post ) {
		void (*postHookFunc) (int ( *func ) (struct map_session_data *sd, va_list args), va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachpc_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_vforeachpc_post[hIndex].func;
			postHookFunc(func, args___copy);
			va_end(args___copy);
		}
	}
	return;
}
void HP_map_vforeachmob(int ( *func ) (struct mob_data *md, va_list args), va_list args) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_vforeachmob_pre ) {
		void (*preHookFunc) (int ( **func ) (struct mob_data *md, va_list args), va_list args);
		*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;
			preHookFunc(&func, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		HPMHooks.source.map.vforeachmob(func, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_vforeachmob_post ) {
		void (*postHookFunc) (int ( *func ) (struct mob_data *md, va_list args), va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachmob_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_vforeachmob_post[hIndex].func;
			postHookFunc(func, args___copy);
			va_end(args___copy);
		}
	}
	return;
}
void HP_map_vforeachnpc(int ( *func ) (struct npc_data *nd, va_list args), va_list args) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_vforeachnpc_pre ) {
		void (*preHookFunc) (int ( **func ) (struct npc_data *nd, va_list args), va_list args);
		*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;
			preHookFunc(&func, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		HPMHooks.source.map.vforeachnpc(func, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_vforeachnpc_post ) {
		void (*postHookFunc) (int ( *func ) (struct npc_data *nd, va_list args), va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachnpc_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_vforeachnpc_post[hIndex].func;
			postHookFunc(func, args___copy);
			va_end(args___copy);
		}
	}
	return;
}
void HP_map_vforeachregen(int ( *func ) (struct block_list *bl, va_list args), va_list args) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_vforeachregen_pre ) {
		void (*preHookFunc) (int ( **func ) (struct block_list *bl, va_list args), va_list args);
		*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;
			preHookFunc(&func, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		HPMHooks.source.map.vforeachregen(func, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_vforeachregen_post ) {
		void (*postHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachregen_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_vforeachregen_post[hIndex].func;
			postHookFunc(func, args___copy);
			va_end(args___copy);
		}
	}
	return;
}
void HP_map_vforeachiddb(int ( *func ) (struct block_list *bl, va_list args), va_list args) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_vforeachiddb_pre ) {
		void (*preHookFunc) (int ( **func ) (struct block_list *bl, va_list args), va_list args);
		*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;
			preHookFunc(&func, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		HPMHooks.source.map.vforeachiddb(func, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_vforeachiddb_post ) {
		void (*postHookFunc) (int ( *func ) (struct block_list *bl, va_list args), va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachiddb_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_vforeachiddb_post[hIndex].func;
			postHookFunc(func, args___copy);
			va_end(args___copy);
		}
	}
	return;
}
int HP_map_vforeachinrange(int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &center, &range, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforeachinrange(func, center, range, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforeachinrange_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinrange_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforeachinrange_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, center, range, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_vforeachinshootrange(int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &center, &range, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforeachinshootrange(func, center, range, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforeachinshootrange_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinshootrange_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforeachinshootrange_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, center, range, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_vforeachinarea(int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &m, &x0, &y0, &x1, &y1, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforeachinarea(func, m, x0, y0, x1, y1, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforeachinarea_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinarea_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforeachinarea_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, m, x0, y0, x1, y1, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_vforcountinrange(int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int count, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &center, &range, &count, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforcountinrange(func, center, range, count, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforcountinrange_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int count, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinrange_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforcountinrange_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, center, range, count, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_vforcountinarea(int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int count, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &m, &x0, &y0, &x1, &y1, &count, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforcountinarea(func, m, x0, y0, x1, y1, count, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforcountinarea_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int count, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforcountinarea_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforcountinarea_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, m, x0, y0, x1, y1, count, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_vforeachinmovearea(int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int16 dx, int16 dy, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &center, &range, &dx, &dy, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforeachinmovearea(func, center, range, dx, dy, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforeachinmovearea_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct block_list *center, int16 range, int16 dx, int16 dy, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmovearea_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforeachinmovearea_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, center, range, dx, dy, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_vforeachincell(int ( *func ) (struct block_list *, va_list), int16 m, int16 x, int16 y, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &m, &x, &y, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforeachincell(func, m, x, y, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforeachincell_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x, int16 y, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachincell_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforeachincell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, m, x, y, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_vforeachinpath(int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int16 range, int length, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &m, &x0, &y0, &x1, &y1, &range, &length, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforeachinpath(func, m, x0, y0, x1, y1, range, length, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforeachinpath_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int16 range, int length, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinpath_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforeachinpath_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, m, x0, y0, x1, y1, range, length, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_vforeachinmap(int ( *func ) (struct block_list *, va_list), int16 m, int type, va_list args) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &m, &type, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.map.vforeachinmap(func, m, type, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_vforeachinmap_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 m, int type, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachinmap_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_vforeachinmap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, m, type, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_map_vforeachininstance(int ( *func ) (struct block_list *, va_list), int16 instance_id, int type, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &instance_id, &type, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.vforeachininstance(func, instance_id, type, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_vforeachininstance_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), int16 instance_id, int type, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_vforeachininstance_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_vforeachininstance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, instance_id, type, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
struct map_session_data* HP_map_id2sd(int id) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2sd_pre ) {
		struct map_session_data* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2sd(id);
	}
	if( HPMHooks.count.HP_map_id2sd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2sd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2sd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct npc_data* HP_map_id2nd(int id) {
	int hIndex = 0;
	struct npc_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2nd_pre ) {
		struct npc_data* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2nd(id);
	}
	if( HPMHooks.count.HP_map_id2nd_post ) {
		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2nd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2nd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct mob_data* HP_map_id2md(int id) {
	int hIndex = 0;
	struct mob_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2md_pre ) {
		struct mob_data* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2md(id);
	}
	if( HPMHooks.count.HP_map_id2md_post ) {
		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2md_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2md_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct flooritem_data* HP_map_id2fi(int id) {
	int hIndex = 0;
	struct flooritem_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2fi_pre ) {
		struct flooritem_data* (*preHookFunc) (int *id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2fi_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_id2fi_pre[hIndex].func;
			retVal___ = preHookFunc(&id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2fi(id);
	}
	if( HPMHooks.count.HP_map_id2fi_post ) {
		struct flooritem_data* (*postHookFunc) (struct flooritem_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2fi_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2fi_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct chat_data* HP_map_id2cd(int id) {
	int hIndex = 0;
	struct chat_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2cd_pre ) {
		struct chat_data* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2cd(id);
	}
	if( HPMHooks.count.HP_map_id2cd_post ) {
		struct chat_data* (*postHookFunc) (struct chat_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2cd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2cd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct skill_unit* HP_map_id2su(int id) {
	int hIndex = 0;
	struct skill_unit* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2su_pre ) {
		struct skill_unit* (*preHookFunc) (int *id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2su_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_id2su_pre[hIndex].func;
			retVal___ = preHookFunc(&id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2su(id);
	}
	if( HPMHooks.count.HP_map_id2su_post ) {
		struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2su_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2su_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct pet_data* HP_map_id2pd(int id) {
	int hIndex = 0;
	struct pet_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2pd_pre ) {
		struct pet_data* (*preHookFunc) (int *id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2pd_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_id2pd_pre[hIndex].func;
			retVal___ = preHookFunc(&id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2pd(id);
	}
	if( HPMHooks.count.HP_map_id2pd_post ) {
		struct pet_data* (*postHookFunc) (struct pet_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2pd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2pd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct homun_data* HP_map_id2hd(int id) {
	int hIndex = 0;
	struct homun_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2hd_pre ) {
		struct homun_data* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2hd(id);
	}
	if( HPMHooks.count.HP_map_id2hd_post ) {
		struct homun_data* (*postHookFunc) (struct homun_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2hd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2hd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct mercenary_data* HP_map_id2mc(int id) {
	int hIndex = 0;
	struct mercenary_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2mc_pre ) {
		struct mercenary_data* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2mc(id);
	}
	if( HPMHooks.count.HP_map_id2mc_post ) {
		struct mercenary_data* (*postHookFunc) (struct mercenary_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2mc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2mc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct elemental_data* HP_map_id2ed(int id) {
	int hIndex = 0;
	struct elemental_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2ed_pre ) {
		struct elemental_data* (*preHookFunc) (int *id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2ed_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_id2ed_pre[hIndex].func;
			retVal___ = preHookFunc(&id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2ed(id);
	}
	if( HPMHooks.count.HP_map_id2ed_post ) {
		struct elemental_data* (*postHookFunc) (struct elemental_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2ed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2ed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct block_list* HP_map_id2bl(int id) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2bl_pre ) {
		struct block_list* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2bl(id);
	}
	if( HPMHooks.count.HP_map_id2bl_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2bl_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2bl_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
bool HP_map_blid_exists(int id) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.blid_exists(id);
	}
	if( HPMHooks.count.HP_map_blid_exists_post ) {
		bool (*postHookFunc) (bool retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_blid_exists_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_blid_exists_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
int16 HP_map_mapindex2mapid(unsigned short map_index) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.mapindex2mapid(map_index);
	}
	if( HPMHooks.count.HP_map_mapindex2mapid_post ) {
		int16 (*postHookFunc) (int16 retVal___, unsigned short map_index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapindex2mapid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_mapindex2mapid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, map_index);
		}
	}
	return retVal___;
}
int16 HP_map_mapname2mapid(const char *name) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.mapname2mapid(name);
	}
	if( HPMHooks.count.HP_map_mapname2mapid_post ) {
		int16 (*postHookFunc) (int16 retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2mapid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_mapname2mapid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
int HP_map_mapname2ipport(unsigned short name, uint32 *ip, uint16 *port) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.mapname2ipport(name, ip, port);
	}
	if( HPMHooks.count.HP_map_mapname2ipport_post ) {
		int (*postHookFunc) (int retVal___, unsigned short name, uint32 *ip, uint16 *port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_mapname2ipport_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_mapname2ipport_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, ip, port);
		}
	}
	return retVal___;
}
int HP_map_setipport(unsigned short map_index, uint32 ip, uint16 port) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.setipport(map_index, ip, port);
	}
	if( HPMHooks.count.HP_map_setipport_post ) {
		int (*postHookFunc) (int retVal___, unsigned short map_index, uint32 ip, uint16 port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setipport_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_setipport_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, map_index, ip, port);
		}
	}
	return retVal___;
}
int HP_map_eraseipport(unsigned short map_index, uint32 ip, uint16 port) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.eraseipport(map_index, ip, port);
	}
	if( HPMHooks.count.HP_map_eraseipport_post ) {
		int (*postHookFunc) (int retVal___, unsigned short map_index, uint32 ip, uint16 port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseipport_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_eraseipport_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, map_index, ip, port);
		}
	}
	return retVal___;
}
int HP_map_eraseallipport(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.eraseallipport();
	}
	if( HPMHooks.count.HP_map_eraseallipport_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_eraseallipport_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_map_addiddb(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_addiddb_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.addiddb(bl);
	}
	if( HPMHooks.count.HP_map_addiddb_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addiddb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_addiddb_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
void HP_map_deliddb(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_deliddb_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.deliddb(bl);
	}
	if( HPMHooks.count.HP_map_deliddb_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_deliddb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_deliddb_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
struct map_session_data* HP_map_nick2sd(const char *nick) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_nick2sd_pre ) {
		struct map_session_data* (*preHookFunc) (const char **nick);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.nick2sd(nick);
	}
	if( HPMHooks.count.HP_map_nick2sd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, const char *nick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick2sd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_nick2sd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nick);
		}
	}
	return retVal___;
}
struct mob_data* HP_map_getmob_boss(int16 m) {
	int hIndex = 0;
	struct mob_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_getmob_boss_pre ) {
		struct mob_data* (*preHookFunc) (int16 *m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.getmob_boss(m);
	}
	if( HPMHooks.count.HP_map_getmob_boss_post ) {
		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int16 m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getmob_boss_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_getmob_boss_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m);
		}
	}
	return retVal___;
}
struct mob_data* HP_map_id2boss(int id) {
	int hIndex = 0;
	struct mob_data* retVal___ = NULL;
	if( HPMHooks.count.HP_map_id2boss_pre ) {
		struct mob_data* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.id2boss(id);
	}
	if( HPMHooks.count.HP_map_id2boss_post ) {
		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_id2boss_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_id2boss_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
uint32 HP_map_race_id2mask(int race) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_map_race_id2mask_pre ) {
		uint32 (*preHookFunc) (int *race);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_race_id2mask_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_race_id2mask_pre[hIndex].func;
			retVal___ = preHookFunc(&race);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.race_id2mask(race);
	}
	if( HPMHooks.count.HP_map_race_id2mask_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, int race);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_race_id2mask_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_race_id2mask_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, race);
		}
	}
	return retVal___;
}
void HP_map_reloadnpc(bool clear) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_reloadnpc_pre ) {
		void (*preHookFunc) (bool *clear);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.reloadnpc(clear);
	}
	if( HPMHooks.count.HP_map_reloadnpc_post ) {
		void (*postHookFunc) (bool clear);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_reloadnpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_reloadnpc_post[hIndex].func;
			postHookFunc(clear);
		}
	}
	return;
}
int HP_map_check_dir(int s_dir, int t_dir) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.check_dir(s_dir, t_dir);
	}
	if( HPMHooks.count.HP_map_check_dir_post ) {
		int (*postHookFunc) (int retVal___, int s_dir, int t_dir);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_check_dir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_check_dir_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, s_dir, t_dir);
		}
	}
	return retVal___;
}
uint8 HP_map_calc_dir(struct block_list *src, int16 x, int16 y) {
	int hIndex = 0;
	uint8 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.calc_dir(src, x, y);
	}
	if( HPMHooks.count.HP_map_calc_dir_post ) {
		uint8 (*postHookFunc) (uint8 retVal___, struct block_list *src, int16 x, int16 y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_calc_dir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_calc_dir_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, x, y);
		}
	}
	return retVal___;
}
int HP_map_random_dir(struct block_list *bl, short *x, short *y) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.random_dir(bl, x, y);
	}
	if( HPMHooks.count.HP_map_random_dir_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, short *x, short *y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_random_dir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_random_dir_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, x, y);
		}
	}
	return retVal___;
}
int HP_map_cleanup_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.cleanup_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_cleanup_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_cleanup_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_delmap(const char *mapname) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_delmap_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.delmap(mapname);
	}
	if( HPMHooks.count.HP_map_delmap_post ) {
		int (*postHookFunc) (int retVal___, const char *mapname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_delmap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mapname);
		}
	}
	return retVal___;
}
void HP_map_flags_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_flags_init_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.flags_init();
	}
	if( HPMHooks.count.HP_map_flags_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_flags_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_flags_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_map_iwall_set(int16 m, int16 x, int16 y, int size, int8 dir, bool shootable, const char *wall_name) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.iwall_set(m, x, y, size, dir, shootable, wall_name);
	}
	if( HPMHooks.count.HP_map_iwall_set_post ) {
		bool (*postHookFunc) (bool retVal___, int16 m, int16 x, int16 y, int size, int8 dir, bool shootable, const char *wall_name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_set_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_iwall_set_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, x, y, size, dir, shootable, wall_name);
		}
	}
	return retVal___;
}
void HP_map_iwall_get(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_iwall_get_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.iwall_get(sd);
	}
	if( HPMHooks.count.HP_map_iwall_get_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_get_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_iwall_get_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_map_iwall_remove(const char *wall_name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_iwall_remove_pre ) {
		void (*preHookFunc) (const char **wall_name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.iwall_remove(wall_name);
	}
	if( HPMHooks.count.HP_map_iwall_remove_post ) {
		void (*postHookFunc) (const char *wall_name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_iwall_remove_post[hIndex].func;
			postHookFunc(wall_name);
		}
	}
	return;
}
int HP_map_addmobtolist(unsigned short m, struct spawn_data *spawn) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.addmobtolist(m, spawn);
	}
	if( HPMHooks.count.HP_map_addmobtolist_post ) {
		int (*postHookFunc) (int retVal___, unsigned short m, struct spawn_data *spawn);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmobtolist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_addmobtolist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, spawn);
		}
	}
	return retVal___;
}
void HP_map_spawnmobs(int16 m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_spawnmobs_pre ) {
		void (*preHookFunc) (int16 *m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.spawnmobs(m);
	}
	if( HPMHooks.count.HP_map_spawnmobs_post ) {
		void (*postHookFunc) (int16 m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_spawnmobs_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_spawnmobs_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_map_removemobs(int16 m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_removemobs_pre ) {
		void (*preHookFunc) (int16 *m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.removemobs(m);
	}
	if( HPMHooks.count.HP_map_removemobs_post ) {
		void (*postHookFunc) (int16 m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_removemobs_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_map_addmap2db(struct map_data *m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_addmap2db_pre ) {
		void (*preHookFunc) (struct map_data **m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.addmap2db(m);
	}
	if( HPMHooks.count.HP_map_addmap2db_post ) {
		void (*postHookFunc) (struct map_data *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap2db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_addmap2db_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_map_removemapdb(struct map_data *m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_removemapdb_pre ) {
		void (*preHookFunc) (struct map_data **m);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.removemapdb(m);
	}
	if( HPMHooks.count.HP_map_removemapdb_post ) {
		void (*postHookFunc) (struct map_data *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemapdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_removemapdb_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_map_clean(int i) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_clean_pre ) {
		void (*preHookFunc) (int *i);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.clean(i);
	}
	if( HPMHooks.count.HP_map_clean_post ) {
		void (*postHookFunc) (int i);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_clean_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_clean_post[hIndex].func;
			postHookFunc(i);
		}
	}
	return;
}
void HP_map_do_shutdown(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_do_shutdown_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.do_shutdown();
	}
	if( HPMHooks.count.HP_map_do_shutdown_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_do_shutdown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_do_shutdown_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_map_freeblock_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.freeblock_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_map_freeblock_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_freeblock_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_freeblock_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_map_searchrandfreecell(int16 m, const struct block_list *bl, int16 *x, int16 *y, int stack) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_searchrandfreecell_pre ) {
		int (*preHookFunc) (int16 *m, const struct block_list **bl, 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, &bl, &x, &y, &stack);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.searchrandfreecell(m, bl, x, y, stack);
	}
	if( HPMHooks.count.HP_map_searchrandfreecell_post ) {
		int (*postHookFunc) (int retVal___, int16 m, const struct block_list *bl, int16 *x, int16 *y, int stack);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_searchrandfreecell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_searchrandfreecell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, bl, x, y, stack);
		}
	}
	return retVal___;
}
int HP_map_count_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.count_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_count_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_count_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_count_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
struct DBData HP_map_create_charid2nick(union DBKey key, va_list args) {
	int hIndex = 0;
	struct DBData retVal___ = { 0 };
	if( HPMHooks.count.HP_map_create_charid2nick_pre ) {
		struct DBData (*preHookFunc) (union 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;
			retVal___ = preHookFunc(&key, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.map.create_charid2nick(key, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_create_charid2nick_post ) {
		struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_create_charid2nick_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_create_charid2nick_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_map_removemobs_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.removemobs_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_removemobs_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_removemobs_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_removemobs_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
struct mapcell HP_map_gat2cell(int gat) {
	int hIndex = 0;
	struct mapcell retVal___ = { 0 };
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.gat2cell(gat);
	}
	if( HPMHooks.count.HP_map_gat2cell_post ) {
		struct mapcell (*postHookFunc) (struct mapcell retVal___, int gat);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_gat2cell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_gat2cell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, gat);
		}
	}
	return retVal___;
}
int HP_map_cell2gat(struct mapcell cell) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.cell2gat(cell);
	}
	if( HPMHooks.count.HP_map_cell2gat_post ) {
		int (*postHookFunc) (int retVal___, struct mapcell cell);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cell2gat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_cell2gat_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cell);
		}
	}
	return retVal___;
}
int HP_map_getcellp(struct map_data *m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_getcellp_pre ) {
		int (*preHookFunc) (struct map_data **m, const struct block_list **bl, 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, &bl, &x, &y, &cellchk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.getcellp(m, bl, x, y, cellchk);
	}
	if( HPMHooks.count.HP_map_getcellp_post ) {
		int (*postHookFunc) (int retVal___, struct map_data *m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_getcellp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_getcellp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, bl, x, y, cellchk);
		}
	}
	return retVal___;
}
void HP_map_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_setcell_pre ) {
		void (*preHookFunc) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.setcell(m, x, y, cell, flag);
	}
	if( HPMHooks.count.HP_map_setcell_post ) {
		void (*postHookFunc) (int16 m, int16 x, int16 y, cell_t cell, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_setcell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_setcell_post[hIndex].func;
			postHookFunc(m, x, y, cell, flag);
		}
	}
	return;
}
int HP_map_sub_getcellp(struct map_data *m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_sub_getcellp_pre ) {
		int (*preHookFunc) (struct map_data **m, const struct block_list **bl, 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, &bl, &x, &y, &cellchk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.sub_getcellp(m, bl, x, y, cellchk);
	}
	if( HPMHooks.count.HP_map_sub_getcellp_post ) {
		int (*postHookFunc) (int retVal___, struct map_data *m, const struct block_list *bl, int16 x, int16 y, cell_chk cellchk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_getcellp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_sub_getcellp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, bl, x, y, cellchk);
		}
	}
	return retVal___;
}
void HP_map_sub_setcell(int16 m, int16 x, int16 y, cell_t cell, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_sub_setcell_pre ) {
		void (*preHookFunc) (int16 *m, int16 *x, int16 *y, cell_t *cell, bool *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.sub_setcell(m, x, y, cell, flag);
	}
	if( HPMHooks.count.HP_map_sub_setcell_post ) {
		void (*postHookFunc) (int16 m, int16 x, int16 y, cell_t cell, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sub_setcell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_sub_setcell_post[hIndex].func;
			postHookFunc(m, x, y, cell, flag);
		}
	}
	return;
}
void HP_map_iwall_nextxy(int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 *y1) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_iwall_nextxy_pre ) {
		void (*preHookFunc) (int16 *x, int16 *y, int8 *dir, int *pos, int16 **x1, int16 **y1);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.iwall_nextxy(x, y, dir, pos, x1, y1);
	}
	if( HPMHooks.count.HP_map_iwall_nextxy_post ) {
		void (*postHookFunc) (int16 x, int16 y, int8 dir, int pos, int16 *x1, int16 *y1);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_iwall_nextxy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_iwall_nextxy_post[hIndex].func;
			postHookFunc(x, y, dir, pos, x1, y1);
		}
	}
	return;
}
struct DBData HP_map_create_map_data_other_server(union DBKey key, va_list args) {
	int hIndex = 0;
	struct DBData retVal___ = { 0 };
	if( HPMHooks.count.HP_map_create_map_data_other_server_pre ) {
		struct DBData (*preHookFunc) (union 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;
			retVal___ = preHookFunc(&key, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.map.create_map_data_other_server(key, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_create_map_data_other_server_post ) {
		struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_create_map_data_other_server_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_create_map_data_other_server_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_map_eraseallipport_sub(union DBKey key, struct DBData *data, va_list va) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_eraseallipport_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, va___copy);
			va_end(va___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list va___copy; va_copy(va___copy, va);
		retVal___ = HPMHooks.source.map.eraseallipport_sub(key, data, va___copy);
		va_end(va___copy);
	}
	if( HPMHooks.count.HP_map_eraseallipport_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list va);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_eraseallipport_sub_post; hIndex++ ) {
			va_list va___copy; va_copy(va___copy, va);
			postHookFunc = HPMHooks.list.HP_map_eraseallipport_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, va___copy);
			va_end(va___copy);
		}
	}
	return retVal___;
}
char* HP_map_init_mapcache(FILE *fp) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_map_init_mapcache_pre ) {
		char* (*preHookFunc) (FILE **fp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.init_mapcache(fp);
	}
	if( HPMHooks.count.HP_map_init_mapcache_post ) {
		char* (*postHookFunc) (char* retVal___, FILE *fp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_init_mapcache_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_init_mapcache_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fp);
		}
	}
	return retVal___;
}
int HP_map_readfromcache(struct map_data *m, char *buffer) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.readfromcache(m, buffer);
	}
	if( HPMHooks.count.HP_map_readfromcache_post ) {
		int (*postHookFunc) (int retVal___, struct map_data *m, char *buffer);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readfromcache_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_readfromcache_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, buffer);
		}
	}
	return retVal___;
}
int HP_map_addmap(const char *mapname) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.addmap(mapname);
	}
	if( HPMHooks.count.HP_map_addmap_post ) {
		int (*postHookFunc) (int retVal___, const char *mapname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_addmap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_addmap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mapname);
		}
	}
	return retVal___;
}
void HP_map_delmapid(int id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_delmapid_pre ) {
		void (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.delmapid(id);
	}
	if( HPMHooks.count.HP_map_delmapid_post ) {
		void (*postHookFunc) (int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_delmapid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_delmapid_post[hIndex].func;
			postHookFunc(id);
		}
	}
	return;
}
void HP_map_zone_db_clear(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_zone_db_clear_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.zone_db_clear();
	}
	if( HPMHooks.count.HP_map_zone_db_clear_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_db_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_db_clear_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_map_list_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_list_final_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.list_final();
	}
	if( HPMHooks.count.HP_map_list_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_list_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_list_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_map_waterheight(char *mapname) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.waterheight(mapname);
	}
	if( HPMHooks.count.HP_map_waterheight_post ) {
		int (*postHookFunc) (int retVal___, char *mapname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_waterheight_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_waterheight_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mapname);
		}
	}
	return retVal___;
}
int HP_map_readgat(struct map_data *m) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.readgat(m);
	}
	if( HPMHooks.count.HP_map_readgat_post ) {
		int (*postHookFunc) (int retVal___, struct map_data *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readgat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_readgat_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m);
		}
	}
	return retVal___;
}
int HP_map_readallmaps(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.readallmaps();
	}
	if( HPMHooks.count.HP_map_readallmaps_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_readallmaps_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_readallmaps_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_map_config_read(const char *filename, bool imported) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_map_config_read_pre ) {
		bool (*preHookFunc) (const char **filename, bool *imported);
		*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(&filename, &imported);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.config_read(filename, imported);
	}
	if( HPMHooks.count.HP_map_config_read_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename, bool imported);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_config_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, imported);
		}
	}
	return retVal___;
}
bool HP_map_read_npclist(const char *filename, bool imported) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_map_read_npclist_pre ) {
		bool (*preHookFunc) (const char **filename, bool *imported);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_read_npclist_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_read_npclist_pre[hIndex].func;
			retVal___ = preHookFunc(&filename, &imported);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.read_npclist(filename, imported);
	}
	if( HPMHooks.count.HP_map_read_npclist_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename, bool imported);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_read_npclist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_read_npclist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, imported);
		}
	}
	return retVal___;
}
bool HP_map_inter_config_read(const char *filename, bool imported) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_map_inter_config_read_pre ) {
		bool (*preHookFunc) (const char **filename, bool *imported);
		*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(&filename, &imported);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.inter_config_read(filename, imported);
	}
	if( HPMHooks.count.HP_map_inter_config_read_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename, bool imported);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_inter_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_inter_config_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, imported);
		}
	}
	return retVal___;
}
bool HP_map_inter_config_read_database_names(const char *filename, const struct config_t *config, bool imported) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_map_inter_config_read_database_names_pre ) {
		bool (*preHookFunc) (const char **filename, const struct config_t **config, bool *imported);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_inter_config_read_database_names_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_inter_config_read_database_names_pre[hIndex].func;
			retVal___ = preHookFunc(&filename, &config, &imported);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.inter_config_read_database_names(filename, config, imported);
	}
	if( HPMHooks.count.HP_map_inter_config_read_database_names_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename, const struct config_t *config, bool imported);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_inter_config_read_database_names_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_inter_config_read_database_names_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, config, imported);
		}
	}
	return retVal___;
}
bool HP_map_inter_config_read_connection(const char *filename, const struct config_t *config, bool imported) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_map_inter_config_read_connection_pre ) {
		bool (*preHookFunc) (const char **filename, const struct config_t **config, bool *imported);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_inter_config_read_connection_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_inter_config_read_connection_pre[hIndex].func;
			retVal___ = preHookFunc(&filename, &config, &imported);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.inter_config_read_connection(filename, config, imported);
	}
	if( HPMHooks.count.HP_map_inter_config_read_connection_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename, const struct config_t *config, bool imported);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_inter_config_read_connection_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_inter_config_read_connection_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, config, imported);
		}
	}
	return retVal___;
}
int HP_map_sql_init(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.sql_init();
	}
	if( HPMHooks.count.HP_map_sql_init_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sql_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_sql_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_map_sql_close(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.sql_close();
	}
	if( HPMHooks.count.HP_map_sql_close_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_sql_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_sql_close_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_map_zone_mf_cache(int m, char *flag, char *params) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.zone_mf_cache(m, flag, params);
	}
	if( HPMHooks.count.HP_map_zone_mf_cache_post ) {
		bool (*postHookFunc) (bool retVal___, int m, char *flag, char *params);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_mf_cache_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_mf_cache_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, flag, params);
		}
	}
	return retVal___;
}
unsigned short HP_map_zone_str2itemid(const char *name) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.zone_str2itemid(name);
	}
	if( HPMHooks.count.HP_map_zone_str2itemid_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_str2itemid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_str2itemid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
unsigned short HP_map_zone_str2skillid(const char *name) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.zone_str2skillid(name);
	}
	if( HPMHooks.count.HP_map_zone_str2skillid_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_str2skillid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_str2skillid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
enum bl_type HP_map_zone_bl_type(const char *entry, enum map_zone_skill_subtype *subtype) {
	int hIndex = 0;
	enum bl_type retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.zone_bl_type(entry, subtype);
	}
	if( HPMHooks.count.HP_map_zone_bl_type_post ) {
		enum bl_type (*postHookFunc) (enum bl_type retVal___, const char *entry, enum map_zone_skill_subtype *subtype);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_bl_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_bl_type_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, entry, subtype);
		}
	}
	return retVal___;
}
void HP_map_read_zone_db(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_read_zone_db_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.read_zone_db();
	}
	if( HPMHooks.count.HP_map_read_zone_db_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_read_zone_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_read_zone_db_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_map_db_final(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_db_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.db_final(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_db_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_db_final_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_db_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_map_nick_db_final(union DBKey key, struct DBData *data, va_list args) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_nick_db_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.map.nick_db_final(key, data, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_map_nick_db_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_nick_db_final_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_map_nick_db_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_map_cleanup_db_sub(union DBKey key, struct DBData *data, va_list va) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_map_cleanup_db_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, va___copy);
			va_end(va___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list va___copy; va_copy(va___copy, va);
		retVal___ = HPMHooks.source.map.cleanup_db_sub(key, data, va___copy);
		va_end(va___copy);
	}
	if( HPMHooks.count.HP_map_cleanup_db_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list va);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_cleanup_db_sub_post; hIndex++ ) {
			va_list va___copy; va_copy(va___copy, va);
			postHookFunc = HPMHooks.list.HP_map_cleanup_db_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, va___copy);
			va_end(va___copy);
		}
	}
	return retVal___;
}
int HP_map_abort_sub(struct map_session_data *sd, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.map.abort_sub(sd, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_map_abort_sub_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_abort_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_map_abort_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_map_update_cell_bl(struct block_list *bl, bool increase) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_update_cell_bl_pre ) {
		void (*preHookFunc) (struct block_list **bl, bool *increase);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_update_cell_bl_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_update_cell_bl_pre[hIndex].func;
			preHookFunc(&bl, &increase);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.update_cell_bl(bl, increase);
	}
	if( HPMHooks.count.HP_map_update_cell_bl_post ) {
		void (*postHookFunc) (struct block_list *bl, bool increase);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_update_cell_bl_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_update_cell_bl_post[hIndex].func;
			postHookFunc(bl, increase);
		}
	}
	return;
}
int HP_map_get_new_bonus_id(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.get_new_bonus_id();
	}
	if( HPMHooks.count.HP_map_get_new_bonus_id_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_get_new_bonus_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_get_new_bonus_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.add_questinfo(m, qi);
	}
	if( HPMHooks.count.HP_map_add_questinfo_post ) {
		void (*postHookFunc) (int m, struct questinfo *qi);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_add_questinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_add_questinfo_post[hIndex].func;
			postHookFunc(m, qi);
		}
	}
	return;
}
bool HP_map_remove_questinfo(int m, struct npc_data *nd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.remove_questinfo(m, nd);
	}
	if( HPMHooks.count.HP_map_remove_questinfo_post ) {
		bool (*postHookFunc) (bool retVal___, int m, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_remove_questinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_remove_questinfo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m, nd);
		}
	}
	return retVal___;
}
struct map_zone_data* HP_map_merge_zone(struct map_zone_data *main, struct map_zone_data *other) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.map.merge_zone(main, other);
	}
	if( HPMHooks.count.HP_map_merge_zone_post ) {
		struct map_zone_data* (*postHookFunc) (struct map_zone_data* retVal___, struct map_zone_data *main, struct map_zone_data *other);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_merge_zone_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_merge_zone_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, main, other);
		}
	}
	return retVal___;
}
void HP_map_zone_clear_single(struct map_zone_data *zone) {
	int hIndex = 0;
	if( HPMHooks.count.HP_map_zone_clear_single_pre ) {
		void (*preHookFunc) (struct map_zone_data **zone);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_clear_single_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_map_zone_clear_single_pre[hIndex].func;
			preHookFunc(&zone);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.map.zone_clear_single(zone);
	}
	if( HPMHooks.count.HP_map_zone_clear_single_post ) {
		void (*postHookFunc) (struct map_zone_data *zone);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_map_zone_clear_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_map_zone_clear_single_post[hIndex].func;
			postHookFunc(zone);
		}
	}
	return;
}
/* mapindex_interface */
int HP_mapindex_init(void) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_mapindex_init_pre ) {
		int (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_init_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapindex.init();
	}
	if( HPMHooks.count.HP_mapindex_init_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_mapindex_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mapindex_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mapindex.final();
	}
	if( HPMHooks.count.HP_mapindex_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_mapindex_addmap(int index, const char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_mapindex_addmap_pre ) {
		int (*preHookFunc) (int *index, const char **name);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_addmap_pre[hIndex].func;
			retVal___ = preHookFunc(&index, &name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapindex.addmap(index, name);
	}
	if( HPMHooks.count.HP_mapindex_addmap_post ) {
		int (*postHookFunc) (int retVal___, int index, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_addmap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_addmap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, index, name);
		}
	}
	return retVal___;
}
void HP_mapindex_removemap(int index) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mapindex_removemap_pre ) {
		void (*preHookFunc) (int *index);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_removemap_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_removemap_pre[hIndex].func;
			preHookFunc(&index);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mapindex.removemap(index);
	}
	if( HPMHooks.count.HP_mapindex_removemap_post ) {
		void (*postHookFunc) (int index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_removemap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_removemap_post[hIndex].func;
			postHookFunc(index);
		}
	}
	return;
}
const char* HP_mapindex_getmapname(const char *string, char *output) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_mapindex_getmapname_pre ) {
		const char* (*preHookFunc) (const char **string, char **output);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_getmapname_pre[hIndex].func;
			retVal___ = preHookFunc(&string, &output);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapindex.getmapname(string, output);
	}
	if( HPMHooks.count.HP_mapindex_getmapname_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *string, char *output);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_getmapname_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, string, output);
		}
	}
	return retVal___;
}
const char* HP_mapindex_getmapname_ext(const char *string, char *output) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_mapindex_getmapname_ext_pre ) {
		const char* (*preHookFunc) (const char **string, char **output);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_ext_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_getmapname_ext_pre[hIndex].func;
			retVal___ = preHookFunc(&string, &output);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapindex.getmapname_ext(string, output);
	}
	if( HPMHooks.count.HP_mapindex_getmapname_ext_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *string, char *output);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_getmapname_ext_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_getmapname_ext_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, string, output);
		}
	}
	return retVal___;
}
unsigned short HP_mapindex_name2id(const char *p1) {
	int hIndex = 0;
	unsigned short retVal___ = 0;
	if( HPMHooks.count.HP_mapindex_name2id_pre ) {
		unsigned short (*preHookFunc) (const char **p1);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_name2id_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_name2id_pre[hIndex].func;
			retVal___ = preHookFunc(&p1);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapindex.name2id(p1);
	}
	if( HPMHooks.count.HP_mapindex_name2id_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, const char *p1);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_name2id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_name2id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p1);
		}
	}
	return retVal___;
}
const char* HP_mapindex_id2name(uint16 id, const char *file, int line, const char *func) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_mapindex_id2name_pre ) {
		const char* (*preHookFunc) (uint16 *id, const char **file, int *line, const char **func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_id2name_pre[hIndex].func;
			retVal___ = preHookFunc(&id, &file, &line, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapindex.id2name(id, file, line, func);
	}
	if( HPMHooks.count.HP_mapindex_id2name_post ) {
		const char* (*postHookFunc) (const char* retVal___, uint16 id, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_id2name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_id2name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id, file, line, func);
		}
	}
	return retVal___;
}
bool HP_mapindex_check_default(void) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_mapindex_check_default_pre ) {
		bool (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_check_default_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapindex_check_default_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapindex.check_default();
	}
	if( HPMHooks.count.HP_mapindex_check_default_post ) {
		bool (*postHookFunc) (bool retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapindex_check_default_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapindex_check_default_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
/* mapit_interface */
struct s_mapiterator* HP_mapit_alloc(enum e_mapitflags flags, enum bl_type types) {
	int hIndex = 0;
	struct s_mapiterator* retVal___ = NULL;
	if( HPMHooks.count.HP_mapit_alloc_pre ) {
		struct s_mapiterator* (*preHookFunc) (enum e_mapitflags *flags, enum bl_type *types);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapit.alloc(flags, types);
	}
	if( HPMHooks.count.HP_mapit_alloc_post ) {
		struct s_mapiterator* (*postHookFunc) (struct s_mapiterator* retVal___, enum e_mapitflags flags, enum bl_type types);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_alloc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapit_alloc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, flags, types);
		}
	}
	return retVal___;
}
void HP_mapit_free(struct s_mapiterator *iter) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mapit_free_pre ) {
		void (*preHookFunc) (struct s_mapiterator **iter);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mapit.free(iter);
	}
	if( HPMHooks.count.HP_mapit_free_post ) {
		void (*postHookFunc) (struct s_mapiterator *iter);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_free_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapit_free_post[hIndex].func;
			postHookFunc(iter);
		}
	}
	return;
}
struct block_list* HP_mapit_first(struct s_mapiterator *iter) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_mapit_first_pre ) {
		struct block_list* (*preHookFunc) (struct s_mapiterator **iter);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapit.first(iter);
	}
	if( HPMHooks.count.HP_mapit_first_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct s_mapiterator *iter);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_first_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapit_first_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, iter);
		}
	}
	return retVal___;
}
struct block_list* HP_mapit_last(struct s_mapiterator *iter) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_mapit_last_pre ) {
		struct block_list* (*preHookFunc) (struct s_mapiterator **iter);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapit.last(iter);
	}
	if( HPMHooks.count.HP_mapit_last_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct s_mapiterator *iter);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_last_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapit_last_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, iter);
		}
	}
	return retVal___;
}
struct block_list* HP_mapit_next(struct s_mapiterator *iter) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_mapit_next_pre ) {
		struct block_list* (*preHookFunc) (struct s_mapiterator **iter);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapit.next(iter);
	}
	if( HPMHooks.count.HP_mapit_next_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct s_mapiterator *iter);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_next_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapit_next_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, iter);
		}
	}
	return retVal___;
}
struct block_list* HP_mapit_prev(struct s_mapiterator *iter) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_mapit_prev_pre ) {
		struct block_list* (*preHookFunc) (struct s_mapiterator **iter);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapit.prev(iter);
	}
	if( HPMHooks.count.HP_mapit_prev_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct s_mapiterator *iter);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_prev_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapit_prev_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, iter);
		}
	}
	return retVal___;
}
bool HP_mapit_exists(struct s_mapiterator *iter) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapit.exists(iter);
	}
	if( HPMHooks.count.HP_mapit_exists_post ) {
		bool (*postHookFunc) (bool retVal___, struct s_mapiterator *iter);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapit_exists_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapit_exists_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, iter);
		}
	}
	return retVal___;
}
/* mapreg_interface */
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mapreg.init();
	}
	if( HPMHooks.count.HP_mapreg_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_mapreg_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mapreg_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapreg_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mapreg.final();
	}
	if( HPMHooks.count.HP_mapreg_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_mapreg_readreg(int64 uid) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapreg.readreg(uid);
	}
	if( HPMHooks.count.HP_mapreg_readreg_post ) {
		int (*postHookFunc) (int retVal___, int64 uid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readreg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_readreg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, uid);
		}
	}
	return retVal___;
}
char* HP_mapreg_readregstr(int64 uid) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapreg.readregstr(uid);
	}
	if( HPMHooks.count.HP_mapreg_readregstr_post ) {
		char* (*postHookFunc) (char* retVal___, int64 uid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_readregstr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_readregstr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, uid);
		}
	}
	return retVal___;
}
bool HP_mapreg_setreg(int64 uid, int val) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapreg.setreg(uid, val);
	}
	if( HPMHooks.count.HP_mapreg_setreg_post ) {
		bool (*postHookFunc) (bool retVal___, int64 uid, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setreg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_setreg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, uid, val);
		}
	}
	return retVal___;
}
bool HP_mapreg_setregstr(int64 uid, const char *str) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapreg.setregstr(uid, str);
	}
	if( HPMHooks.count.HP_mapreg_setregstr_post ) {
		bool (*postHookFunc) (bool retVal___, int64 uid, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_setregstr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_setregstr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, uid, str);
		}
	}
	return retVal___;
}
void HP_mapreg_load(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mapreg_load_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapreg_load_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mapreg.load();
	}
	if( HPMHooks.count.HP_mapreg_load_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_load_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_load_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_mapreg_save(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mapreg_save_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mapreg_save_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mapreg.save();
	}
	if( HPMHooks.count.HP_mapreg_save_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_save_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_mapreg_save_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapreg.save_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mapreg_save_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_save_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_save_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_mapreg_destroyreg(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_mapreg_destroyreg_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mapreg.destroyreg(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mapreg_destroyreg_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_destroyreg_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mapreg_destroyreg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mapreg.reload();
	}
	if( HPMHooks.count.HP_mapreg_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_mapreg_config_read(const char *filename, const struct config_setting_t *config, bool imported) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_mapreg_config_read_pre ) {
		bool (*preHookFunc) (const char **filename, const struct config_setting_t **config, bool *imported);
		*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(&filename, &config, &imported);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mapreg.config_read(filename, config, imported);
	}
	if( HPMHooks.count.HP_mapreg_config_read_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename, const struct config_setting_t *config, bool imported);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mapreg_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mapreg_config_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, config, imported);
		}
	}
	return retVal___;
}
/* md5_interface */
void HP_md5_string(const char *string, char *output) {
	int hIndex = 0;
	if( HPMHooks.count.HP_md5_string_pre ) {
		void (*preHookFunc) (const char **string, char **output);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_md5_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_md5_string_pre[hIndex].func;
			preHookFunc(&string, &output);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.md5.string(string, output);
	}
	if( HPMHooks.count.HP_md5_string_post ) {
		void (*postHookFunc) (const char *string, char *output);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_md5_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_md5_string_post[hIndex].func;
			postHookFunc(string, output);
		}
	}
	return;
}
void HP_md5_binary(const char *string, unsigned char *output) {
	int hIndex = 0;
	if( HPMHooks.count.HP_md5_binary_pre ) {
		void (*preHookFunc) (const char **string, unsigned char **output);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_md5_binary_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_md5_binary_pre[hIndex].func;
			preHookFunc(&string, &output);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.md5.binary(string, output);
	}
	if( HPMHooks.count.HP_md5_binary_post ) {
		void (*postHookFunc) (const char *string, unsigned char *output);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_md5_binary_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_md5_binary_post[hIndex].func;
			postHookFunc(string, output);
		}
	}
	return;
}
void HP_md5_salt(int len, char *output) {
	int hIndex = 0;
	if( HPMHooks.count.HP_md5_salt_pre ) {
		void (*preHookFunc) (int *len, char **output);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_md5_salt_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_md5_salt_pre[hIndex].func;
			preHookFunc(&len, &output);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.md5.salt(len, output);
	}
	if( HPMHooks.count.HP_md5_salt_post ) {
		void (*postHookFunc) (int len, char *output);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_md5_salt_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_md5_salt_post[hIndex].func;
			postHookFunc(len, output);
		}
	}
	return;
}
/* mercenary_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mercenary.init(minimal);
	}
	if( HPMHooks.count.HP_mercenary_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
bool HP_mercenary_class(int class_) {
	int hIndex = 0;
	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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.class(class_);
	}
	if( HPMHooks.count.HP_mercenary_class_post ) {
		bool (*postHookFunc) (bool retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_class_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_class_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
struct view_data* HP_mercenary_get_viewdata(int class_) {
	int hIndex = 0;
	struct view_data* retVal___ = NULL;
	if( HPMHooks.count.HP_mercenary_get_viewdata_pre ) {
		struct view_data* (*preHookFunc) (int *class_);
		*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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.get_viewdata(class_);
	}
	if( HPMHooks.count.HP_mercenary_get_viewdata_post ) {
		struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_viewdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_get_viewdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
int HP_mercenary_create(struct map_session_data *sd, int class_, unsigned int lifetime) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.create(sd, class_, lifetime);
	}
	if( HPMHooks.count.HP_mercenary_create_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int class_, unsigned int lifetime);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, class_, lifetime);
		}
	}
	return retVal___;
}
int HP_mercenary_data_received(const struct s_mercenary *merc, bool flag) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_mercenary_data_received_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.data_received(merc, flag);
	}
	if( HPMHooks.count.HP_mercenary_data_received_post ) {
		int (*postHookFunc) (int retVal___, const struct s_mercenary *merc, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_data_received_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_data_received_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, merc, flag);
		}
	}
	return retVal___;
}
int HP_mercenary_save(struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.save(md);
	}
	if( HPMHooks.count.HP_mercenary_save_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_save_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
void HP_mercenary_heal(struct mercenary_data *md, int hp, int sp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mercenary_heal_pre ) {
		void (*preHookFunc) (struct mercenary_data **md, int *hp, int *sp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mercenary.heal(md, hp, sp);
	}
	if( HPMHooks.count.HP_mercenary_heal_post ) {
		void (*postHookFunc) (struct mercenary_data *md, int hp, int sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_heal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_heal_post[hIndex].func;
			postHookFunc(md, hp, sp);
		}
	}
	return;
}
int HP_mercenary_dead(struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.dead(md);
	}
	if( HPMHooks.count.HP_mercenary_dead_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_dead_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_dead_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mercenary_delete(struct mercenary_data *md, int reply) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.delete(md, reply);
	}
	if( HPMHooks.count.HP_mercenary_delete_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md, int reply);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, reply);
		}
	}
	return retVal___;
}
void HP_mercenary_contract_stop(struct mercenary_data *md) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mercenary_contract_stop_pre ) {
		void (*preHookFunc) (struct mercenary_data **md);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mercenary.contract_stop(md);
	}
	if( HPMHooks.count.HP_mercenary_contract_stop_post ) {
		void (*postHookFunc) (struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_stop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_contract_stop_post[hIndex].func;
			postHookFunc(md);
		}
	}
	return;
}
int HP_mercenary_get_lifetime(struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.get_lifetime(md);
	}
	if( HPMHooks.count.HP_mercenary_get_lifetime_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_lifetime_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_get_lifetime_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mercenary_get_guild(struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.get_guild(md);
	}
	if( HPMHooks.count.HP_mercenary_get_guild_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_guild_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_get_guild_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mercenary_get_faith(struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.get_faith(md);
	}
	if( HPMHooks.count.HP_mercenary_get_faith_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_faith_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_get_faith_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mercenary_set_faith(struct mercenary_data *md, int value) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.set_faith(md, value);
	}
	if( HPMHooks.count.HP_mercenary_set_faith_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_faith_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_set_faith_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, value);
		}
	}
	return retVal___;
}
int HP_mercenary_get_calls(struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.get_calls(md);
	}
	if( HPMHooks.count.HP_mercenary_get_calls_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_get_calls_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_get_calls_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mercenary_set_calls(struct mercenary_data *md, int value) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.set_calls(md, value);
	}
	if( HPMHooks.count.HP_mercenary_set_calls_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_set_calls_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_set_calls_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, value);
		}
	}
	return retVal___;
}
int HP_mercenary_kills(struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.kills(md);
	}
	if( HPMHooks.count.HP_mercenary_kills_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_kills_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_kills_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mercenary_checkskill(struct mercenary_data *md, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.checkskill(md, skill_id);
	}
	if( HPMHooks.count.HP_mercenary_checkskill_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_checkskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_checkskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, skill_id);
		}
	}
	return retVal___;
}
int HP_mercenary_read_db(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.read_db();
	}
	if( HPMHooks.count.HP_mercenary_read_db_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_read_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_mercenary_read_skilldb(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.read_skilldb();
	}
	if( HPMHooks.count.HP_mercenary_read_skilldb_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skilldb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_read_skilldb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_mercenary_killbonus(struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.killbonus(md);
	}
	if( HPMHooks.count.HP_mercenary_killbonus_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_killbonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_killbonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mercenary_search_index(int class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.search_index(class_);
	}
	if( HPMHooks.count.HP_mercenary_search_index_post ) {
		int (*postHookFunc) (int retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_search_index_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_search_index_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
int HP_mercenary_contract_end_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.contract_end_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mercenary_contract_end_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_contract_end_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_contract_end_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
bool HP_mercenary_read_db_sub(char *str[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.read_db_sub(str, columns, current);
	}
	if( HPMHooks.count.HP_mercenary_read_db_sub_post ) {
		bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_db_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_read_db_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, columns, current);
		}
	}
	return retVal___;
}
bool HP_mercenary_read_skill_db_sub(char *str[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mercenary.read_skill_db_sub(str, columns, current);
	}
	if( HPMHooks.count.HP_mercenary_read_skill_db_sub_post ) {
		bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mercenary_read_skill_db_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mercenary_read_skill_db_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, columns, current);
		}
	}
	return retVal___;
}
/* mob_interface */
int HP_mob_init(bool mimimal) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.init(mimimal);
	}
	if( HPMHooks.count.HP_mob_init_post ) {
		int (*postHookFunc) (int retVal___, bool mimimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mimimal);
		}
	}
	return retVal___;
}
int HP_mob_final(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.final();
	}
	if( HPMHooks.count.HP_mob_final_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_mob_reload(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_reload_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_reload_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_reload_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.reload();
	}
	if( HPMHooks.count.HP_mob_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct mob_db* HP_mob_db(int index) {
	int hIndex = 0;
	struct mob_db* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_db_pre ) {
		struct mob_db* (*preHookFunc) (int *index);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.db(index);
	}
	if( HPMHooks.count.HP_mob_db_post ) {
		struct mob_db* (*postHookFunc) (struct mob_db* retVal___, int index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, index);
		}
	}
	return retVal___;
}
struct mob_chat* HP_mob_chat(short id) {
	int hIndex = 0;
	struct mob_chat* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_chat_pre ) {
		struct mob_chat* (*preHookFunc) (short *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.chat(id);
	}
	if( HPMHooks.count.HP_mob_chat_post ) {
		struct mob_chat* (*postHookFunc) (struct mob_chat* retVal___, short id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_chat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_chat_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
int HP_mob_makedummymobdb(int p1) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.makedummymobdb(p1);
	}
	if( HPMHooks.count.HP_mob_makedummymobdb_post ) {
		int (*postHookFunc) (int retVal___, int p1);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_makedummymobdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_makedummymobdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p1);
		}
	}
	return retVal___;
}
int HP_mob_spawn_guardian_sub(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.spawn_guardian_sub(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mob_spawn_guardian_sub_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_spawn_guardian_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_mob_skill_id2skill_idx(int class_, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.skill_id2skill_idx(class_, skill_id);
	}
	if( HPMHooks.count.HP_mob_skill_id2skill_idx_post ) {
		int (*postHookFunc) (int retVal___, int class_, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_id2skill_idx_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_skill_id2skill_idx_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_, skill_id);
		}
	}
	return retVal___;
}
int HP_mob_db_searchname(const char *str) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.db_searchname(str);
	}
	if( HPMHooks.count.HP_mob_db_searchname_post ) {
		int (*postHookFunc) (int retVal___, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_db_searchname_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
int HP_mob_db_searchname_array_sub(struct mob_db *monster, const char *str, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.db_searchname_array_sub(monster, str, flag);
	}
	if( HPMHooks.count.HP_mob_db_searchname_array_sub_post ) {
		int (*postHookFunc) (int retVal___, struct mob_db *monster, const char *str, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_db_searchname_array_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, monster, str, flag);
		}
	}
	return retVal___;
}
void HP_mob_mvptomb_create(struct mob_data *md, char *killer, time_t time) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_mvptomb_create_pre ) {
		void (*preHookFunc) (struct mob_data **md, char **killer, time_t *time);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.mvptomb_create(md, killer, time);
	}
	if( HPMHooks.count.HP_mob_mvptomb_create_post ) {
		void (*postHookFunc) (struct mob_data *md, char *killer, time_t time);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_mvptomb_create_post[hIndex].func;
			postHookFunc(md, killer, time);
		}
	}
	return;
}
void HP_mob_mvptomb_destroy(struct mob_data *md) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_mvptomb_destroy_pre ) {
		void (*preHookFunc) (struct mob_data **md);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.mvptomb_destroy(md);
	}
	if( HPMHooks.count.HP_mob_mvptomb_destroy_post ) {
		void (*postHookFunc) (struct mob_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_mvptomb_destroy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_mvptomb_destroy_post[hIndex].func;
			postHookFunc(md);
		}
	}
	return;
}
int HP_mob_db_searchname_array(struct mob_db **data, int size, const char *str, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.db_searchname_array(data, size, str, flag);
	}
	if( HPMHooks.count.HP_mob_db_searchname_array_post ) {
		int (*postHookFunc) (int retVal___, struct mob_db **data, int size, const char *str, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_searchname_array_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_db_searchname_array_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data, size, str, flag);
		}
	}
	return retVal___;
}
int HP_mob_db_checkid(const int id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.db_checkid(id);
	}
	if( HPMHooks.count.HP_mob_db_checkid_post ) {
		int (*postHookFunc) (int retVal___, const int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_checkid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_db_checkid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
struct view_data* HP_mob_get_viewdata(int class_) {
	int hIndex = 0;
	struct view_data* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_get_viewdata_pre ) {
		struct view_data* (*preHookFunc) (int *class_);
		*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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.get_viewdata(class_);
	}
	if( HPMHooks.count.HP_mob_get_viewdata_post ) {
		struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_viewdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_get_viewdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
int HP_mob_parse_dataset(struct spawn_data *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.parse_dataset(data);
	}
	if( HPMHooks.count.HP_mob_parse_dataset_post ) {
		int (*postHookFunc) (int retVal___, struct spawn_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_dataset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_parse_dataset_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
struct mob_data* HP_mob_spawn_dataset(struct spawn_data *data) {
	int hIndex = 0;
	struct mob_data* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_spawn_dataset_pre ) {
		struct mob_data* (*preHookFunc) (struct spawn_data **data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.spawn_dataset(data);
	}
	if( HPMHooks.count.HP_mob_spawn_dataset_post ) {
		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct spawn_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_dataset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_spawn_dataset_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, data);
		}
	}
	return retVal___;
}
int HP_mob_get_random_id(int type, int flag, int lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.get_random_id(type, flag, lv);
	}
	if( HPMHooks.count.HP_mob_get_random_id_post ) {
		int (*postHookFunc) (int retVal___, int type, int flag, int lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_random_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_get_random_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type, flag, lv);
		}
	}
	return retVal___;
}
bool HP_mob_ksprotected(struct block_list *src, struct block_list *target) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.ksprotected(src, target);
	}
	if( HPMHooks.count.HP_mob_ksprotected_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ksprotected_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_ksprotected_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target);
		}
	}
	return retVal___;
}
struct mob_data* HP_mob_once_spawn_sub(struct block_list *bl, int16 m, int16 x, int16 y, const char *mobname, int class_, const char *event, unsigned int size, unsigned int ai) {
	int hIndex = 0;
	struct mob_data* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_once_spawn_sub_pre ) {
		struct mob_data* (*preHookFunc) (struct block_list **bl, int16 *m, int16 *x, int16 *y, const char **mobname, int *class_, const char **event, unsigned int *size, unsigned int *ai);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.once_spawn_sub(bl, m, x, y, mobname, class_, event, size, ai);
	}
	if( HPMHooks.count.HP_mob_once_spawn_sub_post ) {
		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct block_list *bl, int16 m, int16 x, int16 y, const char *mobname, int class_, const char *event, unsigned int size, unsigned int ai);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_once_spawn_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, m, x, y, mobname, class_, event, size, ai);
		}
	}
	return retVal___;
}
int HP_mob_once_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.once_spawn(sd, m, x, y, mobname, class_, amount, event, size, ai);
	}
	if( HPMHooks.count.HP_mob_once_spawn_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_once_spawn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, m, x, y, mobname, class_, amount, event, size, ai);
		}
	}
	return retVal___;
}
int HP_mob_once_spawn_area(struct map_session_data *sd, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.once_spawn_area(sd, m, x0, y0, x1, y1, mobname, class_, amount, event, size, ai);
	}
	if( HPMHooks.count.HP_mob_once_spawn_area_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, const char *mobname, int class_, int amount, const char *event, unsigned int size, unsigned int ai);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_once_spawn_area_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_once_spawn_area_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, m, x0, y0, x1, y1, mobname, class_, amount, event, size, ai);
		}
	}
	return retVal___;
}
int HP_mob_spawn_guardian(const char *mapname, short x, short y, const char *mobname, int class_, const char *event, int guardian, bool has_index) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.spawn_guardian(mapname, x, y, mobname, class_, event, guardian, has_index);
	}
	if( HPMHooks.count.HP_mob_spawn_guardian_post ) {
		int (*postHookFunc) (int retVal___, const char *mapname, short x, short y, const char *mobname, int class_, const char *event, int guardian, bool has_index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_guardian_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_spawn_guardian_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mapname, x, y, mobname, class_, event, guardian, has_index);
		}
	}
	return retVal___;
}
int HP_mob_spawn_bg(const char *mapname, short x, short y, const char *mobname, int class_, const char *event, unsigned int bg_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.spawn_bg(mapname, x, y, mobname, class_, event, bg_id);
	}
	if( HPMHooks.count.HP_mob_spawn_bg_post ) {
		int (*postHookFunc) (int retVal___, const char *mapname, short x, short y, const char *mobname, int class_, const char *event, unsigned int bg_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_bg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_spawn_bg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mapname, x, y, mobname, class_, event, bg_id);
		}
	}
	return retVal___;
}
int HP_mob_can_reach(struct mob_data *md, struct block_list *bl, int range, int state) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.can_reach(md, bl, range, state);
	}
	if( HPMHooks.count.HP_mob_can_reach_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *bl, int range, int state);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_reach_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_can_reach_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, bl, range, state);
		}
	}
	return retVal___;
}
int HP_mob_linksearch(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.linksearch(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_linksearch_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_linksearch_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_linksearch_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_delayspawn(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.delayspawn(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mob_delayspawn_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_delayspawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_delayspawn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_mob_setdelayspawn(struct mob_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.setdelayspawn(md);
	}
	if( HPMHooks.count.HP_mob_setdelayspawn_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdelayspawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_setdelayspawn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mob_count_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.count_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_count_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_count_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_count_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_spawn(struct mob_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.spawn(md);
	}
	if( HPMHooks.count.HP_mob_spawn_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_spawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_spawn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mob_can_changetarget(const struct mob_data *md, const struct block_list *target, uint32 mode) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_mob_can_changetarget_pre ) {
		int (*preHookFunc) (const struct mob_data **md, const struct block_list **target, uint32 *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.can_changetarget(md, target, mode);
	}
	if( HPMHooks.count.HP_mob_can_changetarget_post ) {
		int (*postHookFunc) (int retVal___, const struct mob_data *md, const struct block_list *target, uint32 mode);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_can_changetarget_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_can_changetarget_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, target, mode);
		}
	}
	return retVal___;
}
int HP_mob_target(struct mob_data *md, struct block_list *bl, int dist) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.target(md, bl, dist);
	}
	if( HPMHooks.count.HP_mob_target_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *bl, int dist);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_target_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, bl, dist);
		}
	}
	return retVal___;
}
int HP_mob_ai_sub_hard_activesearch(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.ai_sub_hard_activesearch(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_ai_sub_hard_activesearch_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_activesearch_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_activesearch_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_ai_sub_hard_changechase(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.ai_sub_hard_changechase(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_ai_sub_hard_changechase_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_changechase_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_changechase_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_ai_sub_hard_bg_ally(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.ai_sub_hard_bg_ally(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_bg_ally_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_bg_ally_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_ai_sub_hard_lootsearch(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.ai_sub_hard_lootsearch(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_lootsearch_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_lootsearch_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_warpchase_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.warpchase_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_warpchase_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_warpchase_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_ai_sub_hard_slavemob(struct mob_data *md, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.ai_sub_hard_slavemob(md, tick);
	}
	if( HPMHooks.count.HP_mob_ai_sub_hard_slavemob_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_slavemob_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_slavemob_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, tick);
		}
	}
	return retVal___;
}
int HP_mob_unlocktarget(struct mob_data *md, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.unlocktarget(md, tick);
	}
	if( HPMHooks.count.HP_mob_unlocktarget_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_unlocktarget_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_unlocktarget_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, tick);
		}
	}
	return retVal___;
}
int HP_mob_randomwalk(struct mob_data *md, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.randomwalk(md, tick);
	}
	if( HPMHooks.count.HP_mob_randomwalk_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_randomwalk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_randomwalk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, tick);
		}
	}
	return retVal___;
}
int HP_mob_warpchase(struct mob_data *md, struct block_list *target) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.warpchase(md, target);
	}
	if( HPMHooks.count.HP_mob_warpchase_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpchase_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_warpchase_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, target);
		}
	}
	return retVal___;
}
bool HP_mob_ai_sub_hard(struct mob_data *md, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.ai_sub_hard(md, tick);
	}
	if( HPMHooks.count.HP_mob_ai_sub_hard_post ) {
		bool (*postHookFunc) (bool retVal___, struct mob_data *md, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, tick);
		}
	}
	return retVal___;
}
int HP_mob_ai_sub_hard_timer(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.ai_sub_hard_timer(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_ai_sub_hard_timer_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_hard_timer_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_hard_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.ai_sub_foreachclient(sd, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_ai_sub_foreachclient_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_foreachclient_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_foreachclient_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_ai_sub_lazy(struct mob_data *md, va_list args) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&md, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.mob.ai_sub_lazy(md, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_mob_ai_sub_lazy_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_sub_lazy_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_mob_ai_sub_lazy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_mob_ai_lazy(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.ai_lazy(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mob_ai_lazy_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_lazy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_ai_lazy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_mob_ai_hard(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.ai_hard(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mob_ai_hard_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_ai_hard_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_ai_hard_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
struct item_drop* HP_mob_setdropitem(int nameid, int qty, struct item_data *data) {
	int hIndex = 0;
	struct item_drop* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_setdropitem_pre ) {
		struct item_drop* (*preHookFunc) (int *nameid, int *qty, struct item_data **data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.setdropitem(nameid, qty, data);
	}
	if( HPMHooks.count.HP_mob_setdropitem_post ) {
		struct item_drop* (*postHookFunc) (struct item_drop* retVal___, int nameid, int qty, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setdropitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_setdropitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nameid, qty, data);
		}
	}
	return retVal___;
}
struct item_drop* HP_mob_setlootitem(struct item *item) {
	int hIndex = 0;
	struct item_drop* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_setlootitem_pre ) {
		struct item_drop* (*preHookFunc) (struct item **item);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.setlootitem(item);
	}
	if( HPMHooks.count.HP_mob_setlootitem_post ) {
		struct item_drop* (*postHookFunc) (struct item_drop* retVal___, struct item *item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_setlootitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_setlootitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, item);
		}
	}
	return retVal___;
}
int HP_mob_delay_item_drop(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.delay_item_drop(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mob_delay_item_drop_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_delay_item_drop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_delay_item_drop_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_mob_item_drop(struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int loot, int drop_rate, unsigned short flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_item_drop_pre ) {
		void (*preHookFunc) (struct mob_data **md, struct item_drop_list **dlist, struct item_drop **ditem, int *loot, int *drop_rate, unsigned short *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.item_drop(md, dlist, ditem, loot, drop_rate, flag);
	}
	if( HPMHooks.count.HP_mob_item_drop_post ) {
		void (*postHookFunc) (struct mob_data *md, struct item_drop_list *dlist, struct item_drop *ditem, int loot, int drop_rate, unsigned short flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_drop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_item_drop_post[hIndex].func;
			postHookFunc(md, dlist, ditem, loot, drop_rate, flag);
		}
	}
	return;
}
int HP_mob_timer_delete(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.timer_delete(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mob_timer_delete_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_timer_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_timer_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_mob_deleteslave_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.deleteslave_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_deleteslave_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_deleteslave_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_deleteslave(struct mob_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.deleteslave(md);
	}
	if( HPMHooks.count.HP_mob_deleteslave_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_deleteslave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_deleteslave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mob_respawn(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.respawn(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_mob_respawn_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_respawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_respawn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_mob_log_damage(struct mob_data *md, struct block_list *src, int damage) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_log_damage_pre ) {
		void (*preHookFunc) (struct mob_data **md, struct block_list **src, int *damage);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.log_damage(md, src, damage);
	}
	if( HPMHooks.count.HP_mob_log_damage_post ) {
		void (*postHookFunc) (struct mob_data *md, struct block_list *src, int damage);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_log_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_log_damage_post[hIndex].func;
			postHookFunc(md, src, damage);
		}
	}
	return;
}
void HP_mob_damage(struct mob_data *md, struct block_list *src, int damage) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_damage_pre ) {
		void (*preHookFunc) (struct mob_data **md, struct block_list **src, int *damage);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.damage(md, src, damage);
	}
	if( HPMHooks.count.HP_mob_damage_post ) {
		void (*postHookFunc) (struct mob_data *md, struct block_list *src, int damage);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_damage_post[hIndex].func;
			postHookFunc(md, src, damage);
		}
	}
	return;
}
int HP_mob_dead(struct mob_data *md, struct block_list *src, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.dead(md, src, type);
	}
	if( HPMHooks.count.HP_mob_dead_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *src, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_dead_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_dead_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, src, type);
		}
	}
	return retVal___;
}
void HP_mob_revive(struct mob_data *md, unsigned int hp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_revive_pre ) {
		void (*preHookFunc) (struct mob_data **md, unsigned int *hp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.revive(md, hp);
	}
	if( HPMHooks.count.HP_mob_revive_post ) {
		void (*postHookFunc) (struct mob_data *md, unsigned int hp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_revive_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_revive_post[hIndex].func;
			postHookFunc(md, hp);
		}
	}
	return;
}
int HP_mob_guardian_guildchange(struct mob_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.guardian_guildchange(md);
	}
	if( HPMHooks.count.HP_mob_guardian_guildchange_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_guardian_guildchange_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_guardian_guildchange_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_mob_random_class(int *value, size_t count) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.random_class(value, count);
	}
	if( HPMHooks.count.HP_mob_random_class_post ) {
		int (*postHookFunc) (int retVal___, int *value, size_t count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_random_class_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_random_class_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, value, count);
		}
	}
	return retVal___;
}
int HP_mob_class_change(struct mob_data *md, int class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.class_change(md, class_);
	}
	if( HPMHooks.count.HP_mob_class_change_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_class_change_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_class_change_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, class_);
		}
	}
	return retVal___;
}
void HP_mob_heal(struct mob_data *md, unsigned int heal) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_heal_pre ) {
		void (*preHookFunc) (struct mob_data **md, unsigned int *heal);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.heal(md, heal);
	}
	if( HPMHooks.count.HP_mob_heal_post ) {
		void (*postHookFunc) (struct mob_data *md, unsigned int heal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_heal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_heal_post[hIndex].func;
			postHookFunc(md, heal);
		}
	}
	return;
}
int HP_mob_warpslave_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.warpslave_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_warpslave_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_warpslave_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_warpslave(struct block_list *bl, int range) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.warpslave(bl, range);
	}
	if( HPMHooks.count.HP_mob_warpslave_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int range);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_warpslave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_warpslave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, range);
		}
	}
	return retVal___;
}
int HP_mob_countslave_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.countslave_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_countslave_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_countslave_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_mob_countslave(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.countslave(bl);
	}
	if( HPMHooks.count.HP_mob_countslave_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_countslave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_countslave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_mob_summonslave(struct mob_data *md2, int *value, int amount, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.summonslave(md2, value, amount, skill_id);
	}
	if( HPMHooks.count.HP_mob_summonslave_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md2, int *value, int amount, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_summonslave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_summonslave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md2, value, amount, skill_id);
		}
	}
	return retVal___;
}
int HP_mob_getfriendhprate_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.getfriendhprate_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_getfriendhprate_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_getfriendhprate_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
struct block_list* HP_mob_getfriendhprate(struct mob_data *md, int min_rate, int max_rate) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_getfriendhprate_pre ) {
		struct block_list* (*preHookFunc) (struct mob_data **md, int *min_rate, int *max_rate);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.getfriendhprate(md, min_rate, max_rate);
	}
	if( HPMHooks.count.HP_mob_getfriendhprate_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct mob_data *md, int min_rate, int max_rate);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendhprate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_getfriendhprate_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, min_rate, max_rate);
		}
	}
	return retVal___;
}
struct block_list* HP_mob_getmasterhpltmaxrate(struct mob_data *md, int rate) {
	int hIndex = 0;
	struct block_list* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_getmasterhpltmaxrate_pre ) {
		struct block_list* (*preHookFunc) (struct mob_data **md, int *rate);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.getmasterhpltmaxrate(md, rate);
	}
	if( HPMHooks.count.HP_mob_getmasterhpltmaxrate_post ) {
		struct block_list* (*postHookFunc) (struct block_list* retVal___, struct mob_data *md, int rate);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getmasterhpltmaxrate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_getmasterhpltmaxrate_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, rate);
		}
	}
	return retVal___;
}
int HP_mob_getfriendstatus_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.mob.getfriendstatus_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_mob_getfriendstatus_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_mob_getfriendstatus_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
struct mob_data* HP_mob_getfriendstatus(struct mob_data *md, int cond1, int cond2) {
	int hIndex = 0;
	struct mob_data* retVal___ = NULL;
	if( HPMHooks.count.HP_mob_getfriendstatus_pre ) {
		struct mob_data* (*preHookFunc) (struct mob_data **md, int *cond1, int *cond2);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.getfriendstatus(md, cond1, cond2);
	}
	if( HPMHooks.count.HP_mob_getfriendstatus_post ) {
		struct mob_data* (*postHookFunc) (struct mob_data* retVal___, struct mob_data *md, int cond1, int cond2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_getfriendstatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_getfriendstatus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, cond1, cond2);
		}
	}
	return retVal___;
}
int HP_mob_skill_use(struct mob_data *md, int64 tick, int event) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.skill_use(md, tick, event);
	}
	if( HPMHooks.count.HP_mob_skill_use_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, int64 tick, int event);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_use_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_skill_use_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, tick, event);
		}
	}
	return retVal___;
}
int HP_mob_skill_event(struct mob_data *md, struct block_list *src, int64 tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.skill_event(md, src, tick, flag);
	}
	if( HPMHooks.count.HP_mob_skill_event_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, struct block_list *src, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_skill_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_skill_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, src, tick, flag);
		}
	}
	return retVal___;
}
int HP_mob_is_clone(int class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.is_clone(class_);
	}
	if( HPMHooks.count.HP_mob_is_clone_post ) {
		int (*postHookFunc) (int retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_is_clone_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_is_clone_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
int HP_mob_clone_spawn(struct map_session_data *sd, int16 m, int16 x, int16 y, const char *event, int master_id, uint32 mode, int flag, unsigned int duration) {
	int hIndex = 0;
	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, uint32 *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.clone_spawn(sd, m, x, y, event, master_id, mode, flag, duration);
	}
	if( HPMHooks.count.HP_mob_clone_spawn_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y, const char *event, int master_id, uint32 mode, int flag, unsigned int duration);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_spawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_clone_spawn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, m, x, y, event, master_id, mode, flag, duration);
		}
	}
	return retVal___;
}
int HP_mob_clone_delete(struct mob_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.clone_delete(md);
	}
	if( HPMHooks.count.HP_mob_clone_delete_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clone_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_clone_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
unsigned int HP_mob_drop_adjust(int baserate, int rate_adjust, unsigned short rate_min, unsigned short rate_max) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.drop_adjust(baserate, rate_adjust, rate_min, rate_max);
	}
	if( HPMHooks.count.HP_mob_drop_adjust_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, int baserate, int rate_adjust, unsigned short rate_min, unsigned short rate_max);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_drop_adjust_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_drop_adjust_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, baserate, rate_adjust, rate_min, rate_max);
		}
	}
	return retVal___;
}
void HP_mob_item_dropratio_adjust(int nameid, int mob_id, int *rate_adjust) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_item_dropratio_adjust_pre ) {
		void (*preHookFunc) (int *nameid, int *mob_id, int **rate_adjust);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.item_dropratio_adjust(nameid, mob_id, rate_adjust);
	}
	if( HPMHooks.count.HP_mob_item_dropratio_adjust_post ) {
		void (*postHookFunc) (int nameid, int mob_id, int *rate_adjust);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_item_dropratio_adjust_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_item_dropratio_adjust_post[hIndex].func;
			postHookFunc(nameid, mob_id, rate_adjust);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.readdb();
	}
	if( HPMHooks.count.HP_mob_readdb_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_readdb_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_mob_lookup_const(const struct config_setting_t *it, const char *name, int *value) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_mob_lookup_const_pre ) {
		bool (*preHookFunc) (const struct config_setting_t **it, const char **name, int **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_lookup_const_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_lookup_const_pre[hIndex].func;
			retVal___ = preHookFunc(&it, &name, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.lookup_const(it, name, value);
	}
	if( HPMHooks.count.HP_mob_lookup_const_post ) {
		bool (*postHookFunc) (bool retVal___, const struct config_setting_t *it, const char *name, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_lookup_const_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_lookup_const_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, it, name, value);
		}
	}
	return retVal___;
}
bool HP_mob_get_const(const struct config_setting_t *it, int *value) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_mob_get_const_pre ) {
		bool (*preHookFunc) (const struct config_setting_t **it, int **value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_const_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_get_const_pre[hIndex].func;
			retVal___ = preHookFunc(&it, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.get_const(it, value);
	}
	if( HPMHooks.count.HP_mob_get_const_post ) {
		bool (*postHookFunc) (bool retVal___, const struct config_setting_t *it, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_get_const_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_get_const_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, it, value);
		}
	}
	return retVal___;
}
int HP_mob_db_validate_entry(struct mob_db *entry, int n, const char *source) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_mob_db_validate_entry_pre ) {
		int (*preHookFunc) (struct mob_db **entry, int *n, const char **source);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_validate_entry_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_db_validate_entry_pre[hIndex].func;
			retVal___ = preHookFunc(&entry, &n, &source);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.db_validate_entry(entry, n, source);
	}
	if( HPMHooks.count.HP_mob_db_validate_entry_post ) {
		int (*postHookFunc) (int retVal___, struct mob_db *entry, int n, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_db_validate_entry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_db_validate_entry_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, entry, n, source);
		}
	}
	return retVal___;
}
int HP_mob_read_libconfig(const char *filename, bool ignore_missing) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_mob_read_libconfig_pre ) {
		int (*preHookFunc) (const char **filename, bool *ignore_missing);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_libconfig_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_read_libconfig_pre[hIndex].func;
			retVal___ = preHookFunc(&filename, &ignore_missing);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.read_libconfig(filename, ignore_missing);
	}
	if( HPMHooks.count.HP_mob_read_libconfig_post ) {
		int (*postHookFunc) (int retVal___, const char *filename, bool ignore_missing);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_libconfig_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_read_libconfig_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, ignore_missing);
		}
	}
	return retVal___;
}
void HP_mob_read_db_additional_fields(struct mob_db *entry, struct config_setting_t *it, int n, const char *source) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_read_db_additional_fields_pre ) {
		void (*preHookFunc) (struct mob_db **entry, struct config_setting_t **it, int *n, const char **source);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_additional_fields_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_read_db_additional_fields_pre[hIndex].func;
			preHookFunc(&entry, &it, &n, &source);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.read_db_additional_fields(entry, it, n, source);
	}
	if( HPMHooks.count.HP_mob_read_db_additional_fields_post ) {
		void (*postHookFunc) (struct mob_db *entry, struct config_setting_t *it, int n, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_additional_fields_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_read_db_additional_fields_post[hIndex].func;
			postHookFunc(entry, it, n, source);
		}
	}
	return;
}
int HP_mob_read_db_sub(struct config_setting_t *mobt, int id, const char *source) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_mob_read_db_sub_pre ) {
		int (*preHookFunc) (struct config_setting_t **mobt, int *id, const char **source);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_read_db_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&mobt, &id, &source);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.read_db_sub(mobt, id, source);
	}
	if( HPMHooks.count.HP_mob_read_db_sub_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *mobt, int id, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_read_db_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, mobt, id, source);
		}
	}
	return retVal___;
}
void HP_mob_read_db_drops_sub(struct mob_db *entry, struct config_setting_t *t) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_read_db_drops_sub_pre ) {
		void (*preHookFunc) (struct mob_db **entry, struct config_setting_t **t);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_drops_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_read_db_drops_sub_pre[hIndex].func;
			preHookFunc(&entry, &t);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.read_db_drops_sub(entry, t);
	}
	if( HPMHooks.count.HP_mob_read_db_drops_sub_post ) {
		void (*postHookFunc) (struct mob_db *entry, struct config_setting_t *t);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_drops_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_read_db_drops_sub_post[hIndex].func;
			postHookFunc(entry, t);
		}
	}
	return;
}
void HP_mob_read_db_mvpdrops_sub(struct mob_db *entry, struct config_setting_t *t) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_read_db_mvpdrops_sub_pre ) {
		void (*preHookFunc) (struct mob_db **entry, struct config_setting_t **t);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_mvpdrops_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_read_db_mvpdrops_sub_pre[hIndex].func;
			preHookFunc(&entry, &t);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.read_db_mvpdrops_sub(entry, t);
	}
	if( HPMHooks.count.HP_mob_read_db_mvpdrops_sub_post ) {
		void (*postHookFunc) (struct mob_db *entry, struct config_setting_t *t);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_mvpdrops_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_read_db_mvpdrops_sub_post[hIndex].func;
			postHookFunc(entry, t);
		}
	}
	return;
}
uint32 HP_mob_read_db_mode_sub(struct mob_db *entry, struct config_setting_t *t) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_mob_read_db_mode_sub_pre ) {
		uint32 (*preHookFunc) (struct mob_db **entry, struct config_setting_t **t);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_mode_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_read_db_mode_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&entry, &t);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.read_db_mode_sub(entry, t);
	}
	if( HPMHooks.count.HP_mob_read_db_mode_sub_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, struct mob_db *entry, struct config_setting_t *t);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_mode_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_read_db_mode_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, entry, t);
		}
	}
	return retVal___;
}
void HP_mob_read_db_stats_sub(struct mob_db *entry, struct config_setting_t *t) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_read_db_stats_sub_pre ) {
		void (*preHookFunc) (struct mob_db **entry, struct config_setting_t **t);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_stats_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_read_db_stats_sub_pre[hIndex].func;
			preHookFunc(&entry, &t);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.read_db_stats_sub(entry, t);
	}
	if( HPMHooks.count.HP_mob_read_db_stats_sub_post ) {
		void (*postHookFunc) (struct mob_db *entry, struct config_setting_t *t);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_db_stats_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_read_db_stats_sub_post[hIndex].func;
			postHookFunc(entry, t);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.name_constants();
	}
	if( HPMHooks.count.HP_mob_name_constants_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_name_constants_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_name_constants_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_mob_readdb_mobavail(char *str[], int columns, int current) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.readdb_mobavail(str, columns, current);
	}
	if( HPMHooks.count.HP_mob_readdb_mobavail_post ) {
		bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_mobavail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_readdb_mobavail_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, columns, current);
		}
	}
	return retVal___;
}
int HP_mob_read_randommonster(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.read_randommonster();
	}
	if( HPMHooks.count.HP_mob_read_randommonster_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_read_randommonster_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_read_randommonster_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_mob_parse_row_chatdb(char **str, const char *source, int line, int *last_msg_id) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.parse_row_chatdb(str, source, line, last_msg_id);
	}
	if( HPMHooks.count.HP_mob_parse_row_chatdb_post ) {
		bool (*postHookFunc) (bool retVal___, char **str, const char *source, int line, int *last_msg_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_chatdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_parse_row_chatdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, source, line, last_msg_id);
		}
	}
	return retVal___;
}
void HP_mob_readchatdb(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_readchatdb_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readchatdb_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_readchatdb_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.readchatdb();
	}
	if( HPMHooks.count.HP_mob_readchatdb_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readchatdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_readchatdb_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_mob_parse_row_mobskilldb(char **str, int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.parse_row_mobskilldb(str, columns, current);
	}
	if( HPMHooks.count.HP_mob_parse_row_mobskilldb_post ) {
		bool (*postHookFunc) (bool retVal___, char **str, int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_parse_row_mobskilldb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_parse_row_mobskilldb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, columns, current);
		}
	}
	return retVal___;
}
void HP_mob_readskilldb(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_readskilldb_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readskilldb_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_readskilldb_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.readskilldb();
	}
	if( HPMHooks.count.HP_mob_readskilldb_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readskilldb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_readskilldb_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_mob_readdb_race2(char *fields[], int columns, int current) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.readdb_race2(fields, columns, current);
	}
	if( HPMHooks.count.HP_mob_readdb_race2_post ) {
		bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_race2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_readdb_race2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fields, columns, current);
		}
	}
	return retVal___;
}
bool HP_mob_readdb_itemratio(char *str[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mob.readdb_itemratio(str, columns, current);
	}
	if( HPMHooks.count.HP_mob_readdb_itemratio_post ) {
		bool (*postHookFunc) (bool retVal___, char *str[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_readdb_itemratio_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_readdb_itemratio_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, columns, current);
		}
	}
	return retVal___;
}
void HP_mob_load(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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.load(minimal);
	}
	if( HPMHooks.count.HP_mob_load_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_load_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_load_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.clear_spawninfo();
	}
	if( HPMHooks.count.HP_mob_clear_spawninfo_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_clear_spawninfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_clear_spawninfo_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_mob_destroy_mob_db(int index) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mob_destroy_mob_db_pre ) {
		void (*preHookFunc) (int *index);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_destroy_mob_db_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mob_destroy_mob_db_pre[hIndex].func;
			preHookFunc(&index);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mob.destroy_mob_db(index);
	}
	if( HPMHooks.count.HP_mob_destroy_mob_db_post ) {
		void (*postHookFunc) (int index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mob_destroy_mob_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mob_destroy_mob_db_post[hIndex].func;
			postHookFunc(index);
		}
	}
	return;
}
/* mutex_interface */
struct mutex_data* HP_mutex_create(void) {
	int hIndex = 0;
	struct mutex_data* retVal___ = NULL;
	if( HPMHooks.count.HP_mutex_create_pre ) {
		struct mutex_data* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_create_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_create_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mutex.create();
	}
	if( HPMHooks.count.HP_mutex_create_post ) {
		struct mutex_data* (*postHookFunc) (struct mutex_data* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_mutex_destroy(struct mutex_data *m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mutex_destroy_pre ) {
		void (*preHookFunc) (struct mutex_data **m);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_destroy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_destroy_pre[hIndex].func;
			preHookFunc(&m);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mutex.destroy(m);
	}
	if( HPMHooks.count.HP_mutex_destroy_post ) {
		void (*postHookFunc) (struct mutex_data *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_destroy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_destroy_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
void HP_mutex_lock(struct mutex_data *m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mutex_lock_pre ) {
		void (*preHookFunc) (struct mutex_data **m);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_lock_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_lock_pre[hIndex].func;
			preHookFunc(&m);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mutex.lock(m);
	}
	if( HPMHooks.count.HP_mutex_lock_post ) {
		void (*postHookFunc) (struct mutex_data *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_lock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_lock_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
bool HP_mutex_trylock(struct mutex_data *m) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_mutex_trylock_pre ) {
		bool (*preHookFunc) (struct mutex_data **m);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_trylock_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_trylock_pre[hIndex].func;
			retVal___ = preHookFunc(&m);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mutex.trylock(m);
	}
	if( HPMHooks.count.HP_mutex_trylock_post ) {
		bool (*postHookFunc) (bool retVal___, struct mutex_data *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_trylock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_trylock_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, m);
		}
	}
	return retVal___;
}
void HP_mutex_unlock(struct mutex_data *m) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mutex_unlock_pre ) {
		void (*preHookFunc) (struct mutex_data **m);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_unlock_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_unlock_pre[hIndex].func;
			preHookFunc(&m);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mutex.unlock(m);
	}
	if( HPMHooks.count.HP_mutex_unlock_post ) {
		void (*postHookFunc) (struct mutex_data *m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_unlock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_unlock_post[hIndex].func;
			postHookFunc(m);
		}
	}
	return;
}
struct cond_data* HP_mutex_cond_create(void) {
	int hIndex = 0;
	struct cond_data* retVal___ = NULL;
	if( HPMHooks.count.HP_mutex_cond_create_pre ) {
		struct cond_data* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_create_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_cond_create_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.mutex.cond_create();
	}
	if( HPMHooks.count.HP_mutex_cond_create_post ) {
		struct cond_data* (*postHookFunc) (struct cond_data* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_cond_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_mutex_cond_destroy(struct cond_data *c) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mutex_cond_destroy_pre ) {
		void (*preHookFunc) (struct cond_data **c);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_destroy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_cond_destroy_pre[hIndex].func;
			preHookFunc(&c);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mutex.cond_destroy(c);
	}
	if( HPMHooks.count.HP_mutex_cond_destroy_post ) {
		void (*postHookFunc) (struct cond_data *c);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_destroy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_cond_destroy_post[hIndex].func;
			postHookFunc(c);
		}
	}
	return;
}
void HP_mutex_cond_wait(struct cond_data *c, struct mutex_data *m, sysint timeout_ticks) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mutex_cond_wait_pre ) {
		void (*preHookFunc) (struct cond_data **c, struct mutex_data **m, sysint *timeout_ticks);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_wait_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_cond_wait_pre[hIndex].func;
			preHookFunc(&c, &m, &timeout_ticks);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mutex.cond_wait(c, m, timeout_ticks);
	}
	if( HPMHooks.count.HP_mutex_cond_wait_post ) {
		void (*postHookFunc) (struct cond_data *c, struct mutex_data *m, sysint timeout_ticks);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_wait_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_cond_wait_post[hIndex].func;
			postHookFunc(c, m, timeout_ticks);
		}
	}
	return;
}
void HP_mutex_cond_signal(struct cond_data *c) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mutex_cond_signal_pre ) {
		void (*preHookFunc) (struct cond_data **c);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_signal_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_cond_signal_pre[hIndex].func;
			preHookFunc(&c);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mutex.cond_signal(c);
	}
	if( HPMHooks.count.HP_mutex_cond_signal_post ) {
		void (*postHookFunc) (struct cond_data *c);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_signal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_cond_signal_post[hIndex].func;
			postHookFunc(c);
		}
	}
	return;
}
void HP_mutex_cond_broadcast(struct cond_data *c) {
	int hIndex = 0;
	if( HPMHooks.count.HP_mutex_cond_broadcast_pre ) {
		void (*preHookFunc) (struct cond_data **c);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_broadcast_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_mutex_cond_broadcast_pre[hIndex].func;
			preHookFunc(&c);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.mutex.cond_broadcast(c);
	}
	if( HPMHooks.count.HP_mutex_cond_broadcast_post ) {
		void (*postHookFunc) (struct cond_data *c);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_mutex_cond_broadcast_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_mutex_cond_broadcast_post[hIndex].func;
			postHookFunc(c);
		}
	}
	return;
}
/* npc_chat_interface */
int HP_npc_chat_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_chat_sub_pre ) {
		int (*preHookFunc) (struct block_list **bl, va_list ap);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_sub_pre; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			preHookFunc = HPMHooks.list.HP_npc_chat_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.npc_chat.sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_npc_chat_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_npc_chat_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_npc_chat_finalize(struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_chat_finalize_pre ) {
		void (*preHookFunc) (struct npc_data **nd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_finalize_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_chat_finalize_pre[hIndex].func;
			preHookFunc(&nd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc_chat.finalize(nd);
	}
	if( HPMHooks.count.HP_npc_chat_finalize_post ) {
		void (*postHookFunc) (struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_finalize_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_chat_finalize_post[hIndex].func;
			postHookFunc(nd);
		}
	}
	return;
}
void HP_npc_chat_def_pattern(struct npc_data *nd, int setid, const char *pattern, const char *label) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_chat_def_pattern_pre ) {
		void (*preHookFunc) (struct npc_data **nd, int *setid, const char **pattern, const char **label);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_def_pattern_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_chat_def_pattern_pre[hIndex].func;
			preHookFunc(&nd, &setid, &pattern, &label);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc_chat.def_pattern(nd, setid, pattern, label);
	}
	if( HPMHooks.count.HP_npc_chat_def_pattern_post ) {
		void (*postHookFunc) (struct npc_data *nd, int setid, const char *pattern, const char *label);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_def_pattern_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_chat_def_pattern_post[hIndex].func;
			postHookFunc(nd, setid, pattern, label);
		}
	}
	return;
}
struct pcrematch_entry* HP_npc_chat_create_pcrematch_entry(struct pcrematch_set *set) {
	int hIndex = 0;
	struct pcrematch_entry* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_chat_create_pcrematch_entry_pre ) {
		struct pcrematch_entry* (*preHookFunc) (struct pcrematch_set **set);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_create_pcrematch_entry_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_chat_create_pcrematch_entry_pre[hIndex].func;
			retVal___ = preHookFunc(&set);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc_chat.create_pcrematch_entry(set);
	}
	if( HPMHooks.count.HP_npc_chat_create_pcrematch_entry_post ) {
		struct pcrematch_entry* (*postHookFunc) (struct pcrematch_entry* retVal___, struct pcrematch_set *set);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_create_pcrematch_entry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_chat_create_pcrematch_entry_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, set);
		}
	}
	return retVal___;
}
void HP_npc_chat_delete_pcreset(struct npc_data *nd, int setid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_chat_delete_pcreset_pre ) {
		void (*preHookFunc) (struct npc_data **nd, int *setid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_delete_pcreset_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_chat_delete_pcreset_pre[hIndex].func;
			preHookFunc(&nd, &setid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc_chat.delete_pcreset(nd, setid);
	}
	if( HPMHooks.count.HP_npc_chat_delete_pcreset_post ) {
		void (*postHookFunc) (struct npc_data *nd, int setid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_delete_pcreset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_chat_delete_pcreset_post[hIndex].func;
			postHookFunc(nd, setid);
		}
	}
	return;
}
void HP_npc_chat_deactivate_pcreset(struct npc_data *nd, int setid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_chat_deactivate_pcreset_pre ) {
		void (*preHookFunc) (struct npc_data **nd, int *setid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_deactivate_pcreset_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_chat_deactivate_pcreset_pre[hIndex].func;
			preHookFunc(&nd, &setid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc_chat.deactivate_pcreset(nd, setid);
	}
	if( HPMHooks.count.HP_npc_chat_deactivate_pcreset_post ) {
		void (*postHookFunc) (struct npc_data *nd, int setid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_deactivate_pcreset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_chat_deactivate_pcreset_post[hIndex].func;
			postHookFunc(nd, setid);
		}
	}
	return;
}
void HP_npc_chat_activate_pcreset(struct npc_data *nd, int setid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_chat_activate_pcreset_pre ) {
		void (*preHookFunc) (struct npc_data **nd, int *setid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_activate_pcreset_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_chat_activate_pcreset_pre[hIndex].func;
			preHookFunc(&nd, &setid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc_chat.activate_pcreset(nd, setid);
	}
	if( HPMHooks.count.HP_npc_chat_activate_pcreset_post ) {
		void (*postHookFunc) (struct npc_data *nd, int setid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_activate_pcreset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_chat_activate_pcreset_post[hIndex].func;
			postHookFunc(nd, setid);
		}
	}
	return;
}
struct pcrematch_set* HP_npc_chat_lookup_pcreset(struct npc_data *nd, int setid) {
	int hIndex = 0;
	struct pcrematch_set* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_chat_lookup_pcreset_pre ) {
		struct pcrematch_set* (*preHookFunc) (struct npc_data **nd, int *setid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_lookup_pcreset_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_chat_lookup_pcreset_pre[hIndex].func;
			retVal___ = preHookFunc(&nd, &setid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc_chat.lookup_pcreset(nd, setid);
	}
	if( HPMHooks.count.HP_npc_chat_lookup_pcreset_post ) {
		struct pcrematch_set* (*postHookFunc) (struct pcrematch_set* retVal___, struct npc_data *nd, int setid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_lookup_pcreset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_chat_lookup_pcreset_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, setid);
		}
	}
	return retVal___;
}
void HP_npc_chat_finalize_pcrematch_entry(struct pcrematch_entry *e) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_chat_finalize_pcrematch_entry_pre ) {
		void (*preHookFunc) (struct pcrematch_entry **e);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_finalize_pcrematch_entry_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_chat_finalize_pcrematch_entry_pre[hIndex].func;
			preHookFunc(&e);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc_chat.finalize_pcrematch_entry(e);
	}
	if( HPMHooks.count.HP_npc_chat_finalize_pcrematch_entry_post ) {
		void (*postHookFunc) (struct pcrematch_entry *e);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_chat_finalize_pcrematch_entry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_chat_finalize_pcrematch_entry_post[hIndex].func;
			postHookFunc(e);
		}
	}
	return;
}
/* npc_interface */
int HP_npc_init(bool minimal) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.init(minimal);
	}
	if( HPMHooks.count.HP_npc_init_post ) {
		int (*postHookFunc) (int retVal___, bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, minimal);
		}
	}
	return retVal___;
}
int HP_npc_final(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.final();
	}
	if( HPMHooks.count.HP_npc_final_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_npc_get_new_npc_id(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.get_new_npc_id();
	}
	if( HPMHooks.count.HP_npc_get_new_npc_id_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_get_new_npc_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_get_new_npc_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
struct view_data* HP_npc_get_viewdata(int class_) {
	int hIndex = 0;
	struct view_data* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_get_viewdata_pre ) {
		struct view_data* (*preHookFunc) (int *class_);
		*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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.get_viewdata(class_);
	}
	if( HPMHooks.count.HP_npc_get_viewdata_post ) {
		struct view_data* (*postHookFunc) (struct view_data* retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_get_viewdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_get_viewdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
int HP_npc_isnear_sub(struct block_list *bl, va_list args) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.npc.isnear_sub(bl, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_npc_isnear_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_sub_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_npc_isnear_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
bool HP_npc_isnear(struct block_list *bl) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.isnear(bl);
	}
	if( HPMHooks.count.HP_npc_isnear_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_isnear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_isnear_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_npc_ontouch_event(struct map_session_data *sd, struct npc_data *nd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.ontouch_event(sd, nd);
	}
	if( HPMHooks.count.HP_npc_ontouch_event_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ontouch_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_ontouch_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nd);
		}
	}
	return retVal___;
}
int HP_npc_ontouch2_event(struct map_session_data *sd, struct npc_data *nd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.ontouch2_event(sd, nd);
	}
	if( HPMHooks.count.HP_npc_ontouch2_event_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ontouch2_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_ontouch2_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nd);
		}
	}
	return retVal___;
}
int HP_npc_onuntouch_event(struct map_session_data *sd, struct npc_data *nd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_onuntouch_event_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_onuntouch_event_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_onuntouch_event_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &nd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.onuntouch_event(sd, nd);
	}
	if( HPMHooks.count.HP_npc_onuntouch_event_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_onuntouch_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_onuntouch_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nd);
		}
	}
	return retVal___;
}
int HP_npc_enable_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.npc.enable_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_npc_enable_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_npc_enable_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_npc_enable(const char *name, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.enable(name, flag);
	}
	if( HPMHooks.count.HP_npc_enable_post ) {
		int (*postHookFunc) (int retVal___, const char *name, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_enable_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_enable_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, flag);
		}
	}
	return retVal___;
}
struct npc_data* HP_npc_name2id(const char *name) {
	int hIndex = 0;
	struct npc_data* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_name2id_pre ) {
		struct npc_data* (*preHookFunc) (const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.name2id(name);
	}
	if( HPMHooks.count.HP_npc_name2id_post ) {
		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_name2id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_name2id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
int HP_npc_event_dequeue(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.event_dequeue(sd);
	}
	if( HPMHooks.count.HP_npc_event_dequeue_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_dequeue_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_dequeue_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
struct DBData HP_npc_event_export_create(union DBKey key, va_list args) {
	int hIndex = 0;
	struct DBData retVal___ = { 0 };
	if( HPMHooks.count.HP_npc_event_export_create_pre ) {
		struct DBData (*preHookFunc) (union 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;
			retVal___ = preHookFunc(&key, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.npc.event_export_create(key, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_npc_event_export_create_post ) {
		struct DBData (*postHookFunc) (struct DBData retVal___, union DBKey key, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_create_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_npc_event_export_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_npc_event_export(struct npc_data *nd, int i) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.event_export(nd, i);
	}
	if( HPMHooks.count.HP_npc_event_export_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd, int i);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_export_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_export_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, i);
		}
	}
	return retVal___;
}
int HP_npc_event_sub(struct map_session_data *sd, struct event_data *ev, const char *eventname) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.event_sub(sd, ev, eventname);
	}
	if( HPMHooks.count.HP_npc_event_sub_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct event_data *ev, const char *eventname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ev, eventname);
		}
	}
	return retVal___;
}
void HP_npc_event_doall_sub(void *key, void *data, va_list ap) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_event_doall_sub_pre ) {
		void (*preHookFunc) (void **key, void **data, va_list ap);
		*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;
			preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		HPMHooks.source.npc.event_doall_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_npc_event_doall_sub_post ) {
		void (*postHookFunc) (void *key, void *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_npc_event_doall_sub_post[hIndex].func;
			postHookFunc(key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return;
}
int HP_npc_event_do(const char *name) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.event_do(name);
	}
	if( HPMHooks.count.HP_npc_event_do_post ) {
		int (*postHookFunc) (int retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_do_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
int HP_npc_event_doall_id(const char *name, int rid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.event_doall_id(name, rid);
	}
	if( HPMHooks.count.HP_npc_event_doall_id_post ) {
		int (*postHookFunc) (int retVal___, const char *name, int rid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_doall_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, rid);
		}
	}
	return retVal___;
}
int HP_npc_event_doall(const char *name) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.event_doall(name);
	}
	if( HPMHooks.count.HP_npc_event_doall_post ) {
		int (*postHookFunc) (int retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_doall_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_doall_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
int HP_npc_event_do_clock(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.event_do_clock(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_npc_event_do_clock_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_clock_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_do_clock_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_npc_event_do_oninit(bool reload) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_event_do_oninit_pre ) {
		void (*preHookFunc) (bool *reload);
		*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(&reload);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.event_do_oninit(reload);
	}
	if( HPMHooks.count.HP_npc_event_do_oninit_post ) {
		void (*postHookFunc) (bool reload);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_do_oninit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_do_oninit_post[hIndex].func;
			postHookFunc(reload);
		}
	}
	return;
}
int HP_npc_timerevent_export(struct npc_data *nd, int i) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.timerevent_export(nd, i);
	}
	if( HPMHooks.count.HP_npc_timerevent_export_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd, int i);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_export_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_timerevent_export_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, i);
		}
	}
	return retVal___;
}
int HP_npc_timerevent(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.timerevent(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_npc_timerevent_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_timerevent_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_npc_timerevent_start(struct npc_data *nd, int rid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.timerevent_start(nd, rid);
	}
	if( HPMHooks.count.HP_npc_timerevent_start_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd, int rid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_timerevent_start_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, rid);
		}
	}
	return retVal___;
}
int HP_npc_timerevent_stop(struct npc_data *nd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.timerevent_stop(nd);
	}
	if( HPMHooks.count.HP_npc_timerevent_stop_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_stop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_timerevent_stop_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd);
		}
	}
	return retVal___;
}
void HP_npc_timerevent_quit(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_timerevent_quit_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.timerevent_quit(sd);
	}
	if( HPMHooks.count.HP_npc_timerevent_quit_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_timerevent_quit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_timerevent_quit_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int64 HP_npc_gettimerevent_tick(struct npc_data *nd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.gettimerevent_tick(nd);
	}
	if( HPMHooks.count.HP_npc_gettimerevent_tick_post ) {
		int64 (*postHookFunc) (int64 retVal___, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_gettimerevent_tick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_gettimerevent_tick_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd);
		}
	}
	return retVal___;
}
int HP_npc_settimerevent_tick(struct npc_data *nd, int newtimer) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.settimerevent_tick(nd, newtimer);
	}
	if( HPMHooks.count.HP_npc_settimerevent_tick_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd, int newtimer);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_settimerevent_tick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_settimerevent_tick_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, newtimer);
		}
	}
	return retVal___;
}
int HP_npc_event(struct map_session_data *sd, const char *eventname, int ontouch) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.event(sd, eventname, ontouch);
	}
	if( HPMHooks.count.HP_npc_event_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *eventname, int ontouch);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, eventname, ontouch);
		}
	}
	return retVal___;
}
int HP_npc_touch_areanpc_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.npc.touch_areanpc_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_npc_touch_areanpc_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_npc_touch_areanpc_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_npc_touchnext_areanpc(struct map_session_data *sd, bool leavemap) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.touchnext_areanpc(sd, leavemap);
	}
	if( HPMHooks.count.HP_npc_touchnext_areanpc_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, bool leavemap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touchnext_areanpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_touchnext_areanpc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, leavemap);
		}
	}
	return retVal___;
}
int HP_npc_touch_areanpc(struct map_session_data *sd, int16 m, int16 x, int16 y) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.touch_areanpc(sd, m, x, y);
	}
	if( HPMHooks.count.HP_npc_touch_areanpc_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_touch_areanpc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, m, x, y);
		}
	}
	return retVal___;
}
int HP_npc_untouch_areanpc(struct map_session_data *sd, int16 m, int16 x, int16 y) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_untouch_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_untouch_areanpc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_untouch_areanpc_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &m, &x, &y);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.untouch_areanpc(sd, m, x, y);
	}
	if( HPMHooks.count.HP_npc_untouch_areanpc_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int16 m, int16 x, int16 y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_untouch_areanpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_untouch_areanpc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, m, x, y);
		}
	}
	return retVal___;
}
int HP_npc_touch_areanpc2(struct mob_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.touch_areanpc2(md);
	}
	if( HPMHooks.count.HP_npc_touch_areanpc2_post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_touch_areanpc2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_touch_areanpc2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md);
		}
	}
	return retVal___;
}
int HP_npc_check_areanpc(int flag, int16 m, int16 x, int16 y, int16 range) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.check_areanpc(flag, m, x, y, range);
	}
	if( HPMHooks.count.HP_npc_check_areanpc_post ) {
		int (*postHookFunc) (int retVal___, int flag, int16 m, int16 x, int16 y, int16 range);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_check_areanpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_check_areanpc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, flag, m, x, y, range);
		}
	}
	return retVal___;
}
struct npc_data* HP_npc_checknear(struct map_session_data *sd, struct block_list *bl) {
	int hIndex = 0;
	struct npc_data* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_checknear_pre ) {
		struct npc_data* (*preHookFunc) (struct map_session_data **sd, struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.checknear(sd, bl);
	}
	if( HPMHooks.count.HP_npc_checknear_post ) {
		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, struct map_session_data *sd, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_checknear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_checknear_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, bl);
		}
	}
	return retVal___;
}
int HP_npc_globalmessage(const char *name, const char *mes) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.globalmessage(name, mes);
	}
	if( HPMHooks.count.HP_npc_globalmessage_post ) {
		int (*postHookFunc) (int retVal___, const char *name, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_globalmessage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_globalmessage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, mes);
		}
	}
	return retVal___;
}
void HP_npc_run_tomb(struct map_session_data *sd, struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_run_tomb_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.run_tomb(sd, nd);
	}
	if( HPMHooks.count.HP_npc_run_tomb_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_run_tomb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_run_tomb_post[hIndex].func;
			postHookFunc(sd, nd);
		}
	}
	return;
}
int HP_npc_click(struct map_session_data *sd, struct npc_data *nd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.click(sd, nd);
	}
	if( HPMHooks.count.HP_npc_click_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_click_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_click_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nd);
		}
	}
	return retVal___;
}
int HP_npc_scriptcont(struct map_session_data *sd, int id, bool closing) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.scriptcont(sd, id, closing);
	}
	if( HPMHooks.count.HP_npc_scriptcont_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int id, bool closing);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_scriptcont_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_scriptcont_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, id, closing);
		}
	}
	return retVal___;
}
int HP_npc_buysellsel(struct map_session_data *sd, int id, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.buysellsel(sd, id, type);
	}
	if( HPMHooks.count.HP_npc_buysellsel_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int id, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buysellsel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_buysellsel_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, id, type);
		}
	}
	return retVal___;
}
int HP_npc_cashshop_buylist(struct map_session_data *sd, int points, struct itemlist *item_list) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_cashshop_buylist_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, int *points, struct itemlist **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, &item_list);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.cashshop_buylist(sd, points, item_list);
	}
	if( HPMHooks.count.HP_npc_cashshop_buylist_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int points, struct itemlist *item_list);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buylist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_cashshop_buylist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, points, item_list);
		}
	}
	return retVal___;
}
int HP_npc_buylist_sub(struct map_session_data *sd, struct itemlist *item_list, struct npc_data *nd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_buylist_sub_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, struct itemlist **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, &item_list, &nd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.buylist_sub(sd, item_list, nd);
	}
	if( HPMHooks.count.HP_npc_buylist_sub_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct itemlist *item_list, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buylist_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_buylist_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_list, nd);
		}
	}
	return retVal___;
}
int HP_npc_cashshop_buy(struct map_session_data *sd, int nameid, int amount, int points) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.cashshop_buy(sd, nameid, amount, points);
	}
	if( HPMHooks.count.HP_npc_cashshop_buy_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid, int amount, int points);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_cashshop_buy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_cashshop_buy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid, amount, points);
		}
	}
	return retVal___;
}
int HP_npc_buylist(struct map_session_data *sd, struct itemlist *item_list) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_buylist_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, struct itemlist **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, &item_list);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.buylist(sd, item_list);
	}
	if( HPMHooks.count.HP_npc_buylist_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct itemlist *item_list);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_buylist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_buylist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_list);
		}
	}
	return retVal___;
}
int HP_npc_selllist_sub(struct map_session_data *sd, struct itemlist *item_list, struct npc_data *nd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_selllist_sub_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, struct itemlist **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, &item_list, &nd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.selllist_sub(sd, item_list, nd);
	}
	if( HPMHooks.count.HP_npc_selllist_sub_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct itemlist *item_list, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_selllist_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_selllist_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_list, nd);
		}
	}
	return retVal___;
}
int HP_npc_selllist(struct map_session_data *sd, struct itemlist *item_list) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_selllist_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, struct itemlist **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, &item_list);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.selllist(sd, item_list);
	}
	if( HPMHooks.count.HP_npc_selllist_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct itemlist *item_list);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_selllist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_selllist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_list);
		}
	}
	return retVal___;
}
int HP_npc_remove_map(struct npc_data *nd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.remove_map(nd);
	}
	if( HPMHooks.count.HP_npc_remove_map_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_remove_map_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_remove_map_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd);
		}
	}
	return retVal___;
}
int HP_npc_unload_ev(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_unload_ev_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.npc.unload_ev(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_npc_unload_ev_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_npc_unload_ev_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_npc_unload_ev_label(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_unload_ev_label_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.npc.unload_ev_label(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_npc_unload_ev_label_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_ev_label_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_npc_unload_ev_label_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_npc_unload_dup_sub(struct npc_data *nd, va_list args) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&nd, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.npc.unload_dup_sub(nd, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_npc_unload_dup_sub_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_dup_sub_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_npc_unload_dup_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
void HP_npc_unload_duplicates(struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_unload_duplicates_pre ) {
		void (*preHookFunc) (struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.unload_duplicates(nd);
	}
	if( HPMHooks.count.HP_npc_unload_duplicates_post ) {
		void (*postHookFunc) (struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_duplicates_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_unload_duplicates_post[hIndex].func;
			postHookFunc(nd);
		}
	}
	return;
}
int HP_npc_unload(struct npc_data *nd, bool single) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.unload(nd, single);
	}
	if( HPMHooks.count.HP_npc_unload_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd, bool single);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_unload_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, single);
		}
	}
	return retVal___;
}
void HP_npc_clearsrcfile(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_clearsrcfile_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_clearsrcfile_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_clearsrcfile_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.clearsrcfile();
	}
	if( HPMHooks.count.HP_npc_clearsrcfile_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_clearsrcfile_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_clearsrcfile_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_npc_addsrcfile(const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_addsrcfile_pre ) {
		void (*preHookFunc) (const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.addsrcfile(name);
	}
	if( HPMHooks.count.HP_npc_addsrcfile_post ) {
		void (*postHookFunc) (const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_addsrcfile_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_addsrcfile_post[hIndex].func;
			postHookFunc(name);
		}
	}
	return;
}
void HP_npc_delsrcfile(const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_delsrcfile_pre ) {
		void (*preHookFunc) (const char **name);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.delsrcfile(name);
	}
	if( HPMHooks.count.HP_npc_delsrcfile_post ) {
		void (*postHookFunc) (const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_delsrcfile_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_delsrcfile_post[hIndex].func;
			postHookFunc(name);
		}
	}
	return;
}
const char* HP_npc_retainpathreference(const char *filepath) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_retainpathreference_pre ) {
		const char* (*preHookFunc) (const char **filepath);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_retainpathreference_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_retainpathreference_pre[hIndex].func;
			retVal___ = preHookFunc(&filepath);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.retainpathreference(filepath);
	}
	if( HPMHooks.count.HP_npc_retainpathreference_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_retainpathreference_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_retainpathreference_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filepath);
		}
	}
	return retVal___;
}
void HP_npc_releasepathreference(const char *filepath) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_releasepathreference_pre ) {
		void (*preHookFunc) (const char **filepath);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_releasepathreference_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_releasepathreference_pre[hIndex].func;
			preHookFunc(&filepath);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.releasepathreference(filepath);
	}
	if( HPMHooks.count.HP_npc_releasepathreference_post ) {
		void (*postHookFunc) (const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_releasepathreference_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_releasepathreference_post[hIndex].func;
			postHookFunc(filepath);
		}
	}
	return;
}
void HP_npc_parsename(struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_parsename_pre ) {
		void (*preHookFunc) (struct npc_data **nd, const char **name, const char **start, const char **buffer, const char **filepath);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.parsename(nd, name, start, buffer, filepath);
	}
	if( HPMHooks.count.HP_npc_parsename_post ) {
		void (*postHookFunc) (struct npc_data *nd, const char *name, const char *start, const char *buffer, const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsename_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parsename_post[hIndex].func;
			postHookFunc(nd, name, start, buffer, filepath);
		}
	}
	return;
}
int HP_npc_parseview(const char *w4, const char *start, const char *buffer, const char *filepath) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parseview(w4, start, buffer, filepath);
	}
	if( HPMHooks.count.HP_npc_parseview_post ) {
		int (*postHookFunc) (int retVal___, const char *w4, const char *start, const char *buffer, const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parseview_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parseview_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w4, start, buffer, filepath);
		}
	}
	return retVal___;
}
bool HP_npc_viewisid(const char *viewid) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.viewisid(viewid);
	}
	if( HPMHooks.count.HP_npc_viewisid_post ) {
		bool (*postHookFunc) (bool retVal___, const char *viewid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_viewisid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_viewisid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, viewid);
		}
	}
	return retVal___;
}
struct npc_data* HP_npc_create_npc(enum npc_subtype subtype, int m, int x, int y, uint8 dir, int16 class_) {
	int hIndex = 0;
	struct npc_data* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_create_npc_pre ) {
		struct npc_data* (*preHookFunc) (enum npc_subtype *subtype, int *m, int *x, int *y, uint8 *dir, int16 *class_);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_create_npc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_create_npc_pre[hIndex].func;
			retVal___ = preHookFunc(&subtype, &m, &x, &y, &dir, &class_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.create_npc(subtype, m, x, y, dir, class_);
	}
	if( HPMHooks.count.HP_npc_create_npc_post ) {
		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, enum npc_subtype subtype, int m, int x, int y, uint8 dir, int16 class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_create_npc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_create_npc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, subtype, m, x, y, dir, class_);
		}
	}
	return retVal___;
}
struct npc_data* HP_npc_add_warp(char *name, short from_mapid, short from_x, short from_y, short xs, short ys, unsigned short to_mapindex, short to_x, short to_y) {
	int hIndex = 0;
	struct npc_data* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_add_warp_pre ) {
		struct npc_data* (*preHookFunc) (char **name, short *from_mapid, short *from_x, short *from_y, short *xs, short *ys, unsigned short *to_mapindex, short *to_x, short *to_y);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.add_warp(name, from_mapid, from_x, from_y, xs, ys, to_mapindex, to_x, to_y);
	}
	if( HPMHooks.count.HP_npc_add_warp_post ) {
		struct npc_data* (*postHookFunc) (struct npc_data* retVal___, char *name, short from_mapid, short from_x, short from_y, short xs, short ys, unsigned short to_mapindex, short to_x, short to_y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_add_warp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_add_warp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, from_mapid, from_x, from_y, xs, ys, to_mapindex, to_x, to_y);
		}
	}
	return retVal___;
}
const char* HP_npc_parse_warp(const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_parse_warp_pre ) {
		const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval);
		*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, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parse_warp(w1, w2, w3, w4, start, buffer, filepath, retval);
	}
	if( HPMHooks.count.HP_npc_parse_warp_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_warp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_warp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, retval);
		}
	}
	return retVal___;
}
const char* HP_npc_parse_shop(const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_parse_shop_pre ) {
		const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval);
		*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, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parse_shop(w1, w2, w3, w4, start, buffer, filepath, retval);
	}
	if( HPMHooks.count.HP_npc_parse_shop_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_shop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_shop_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, retval);
		}
	}
	return retVal___;
}
const char* HP_npc_parse_unknown_object(const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_parse_unknown_object_pre ) {
		const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_unknown_object_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_parse_unknown_object_pre[hIndex].func;
			retVal___ = preHookFunc(&w1, &w2, &w3, &w4, &start, &buffer, &filepath, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parse_unknown_object(w1, w2, w3, w4, start, buffer, filepath, retval);
	}
	if( HPMHooks.count.HP_npc_parse_unknown_object_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_unknown_object_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_unknown_object_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, retval);
		}
	}
	return retVal___;
}
void HP_npc_convertlabel_db(struct npc_label_list *label_list, const char *filepath) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_convertlabel_db_pre ) {
		void (*preHookFunc) (struct npc_label_list **label_list, const char **filepath);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.convertlabel_db(label_list, filepath);
	}
	if( HPMHooks.count.HP_npc_convertlabel_db_post ) {
		void (*postHookFunc) (struct npc_label_list *label_list, const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_convertlabel_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_convertlabel_db_post[hIndex].func;
			postHookFunc(label_list, filepath);
		}
	}
	return;
}
const char* HP_npc_skip_script(const char *start, const char *buffer, const char *filepath, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_skip_script_pre ) {
		const char* (*preHookFunc) (const char **start, const char **buffer, const char **filepath, int **retval);
		*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, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.skip_script(start, buffer, filepath, retval);
	}
	if( HPMHooks.count.HP_npc_skip_script_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *start, const char *buffer, const char *filepath, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_skip_script_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_skip_script_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, start, buffer, filepath, retval);
		}
	}
	return retVal___;
}
const char* HP_npc_parse_script(const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int options, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_parse_script_pre ) {
		const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int *options, int **retval);
		*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, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parse_script(w1, w2, w3, w4, start, buffer, filepath, options, retval);
	}
	if( HPMHooks.count.HP_npc_parse_script_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int options, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_script_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_script_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, options, retval);
		}
	}
	return retVal___;
}
void HP_npc_add_to_location(struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_add_to_location_pre ) {
		void (*preHookFunc) (struct npc_data **nd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_add_to_location_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_add_to_location_pre[hIndex].func;
			preHookFunc(&nd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.add_to_location(nd);
	}
	if( HPMHooks.count.HP_npc_add_to_location_post ) {
		void (*postHookFunc) (struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_add_to_location_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_add_to_location_post[hIndex].func;
			postHookFunc(nd);
		}
	}
	return;
}
bool HP_npc_duplicate_script_sub(struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_npc_duplicate_script_sub_pre ) {
		bool (*preHookFunc) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_script_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_duplicate_script_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&nd, &snd, &xs, &ys, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.duplicate_script_sub(nd, snd, xs, ys, options);
	}
	if( HPMHooks.count.HP_npc_duplicate_script_sub_post ) {
		bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_script_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_duplicate_script_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, snd, xs, ys, options);
		}
	}
	return retVal___;
}
bool HP_npc_duplicate_shop_sub(struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_npc_duplicate_shop_sub_pre ) {
		bool (*preHookFunc) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_shop_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_duplicate_shop_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&nd, &snd, &xs, &ys, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.duplicate_shop_sub(nd, snd, xs, ys, options);
	}
	if( HPMHooks.count.HP_npc_duplicate_shop_sub_post ) {
		bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_shop_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_duplicate_shop_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, snd, xs, ys, options);
		}
	}
	return retVal___;
}
bool HP_npc_duplicate_warp_sub(struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_npc_duplicate_warp_sub_pre ) {
		bool (*preHookFunc) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_warp_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_duplicate_warp_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&nd, &snd, &xs, &ys, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.duplicate_warp_sub(nd, snd, xs, ys, options);
	}
	if( HPMHooks.count.HP_npc_duplicate_warp_sub_post ) {
		bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_warp_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_duplicate_warp_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, snd, xs, ys, options);
		}
	}
	return retVal___;
}
bool HP_npc_duplicate_sub(struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_npc_duplicate_sub_pre ) {
		bool (*preHookFunc) (struct npc_data **nd, const struct npc_data **snd, int *xs, int *ys, int *options);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_duplicate_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&nd, &snd, &xs, &ys, &options);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.duplicate_sub(nd, snd, xs, ys, options);
	}
	if( HPMHooks.count.HP_npc_duplicate_sub_post ) {
		bool (*postHookFunc) (bool retVal___, struct npc_data *nd, const struct npc_data *snd, int xs, int ys, int options);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_duplicate_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, snd, xs, ys, options);
		}
	}
	return retVal___;
}
const char* HP_npc_parse_duplicate(const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int options, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_parse_duplicate_pre ) {
		const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int *options, int **retval);
		*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, &options, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parse_duplicate(w1, w2, w3, w4, start, buffer, filepath, options, retval);
	}
	if( HPMHooks.count.HP_npc_parse_duplicate_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int options, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_duplicate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_duplicate_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, options, retval);
		}
	}
	return retVal___;
}
int HP_npc_duplicate4instance(struct npc_data *snd, int16 m) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.duplicate4instance(snd, m);
	}
	if( HPMHooks.count.HP_npc_duplicate4instance_post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *snd, int16 m);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_duplicate4instance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_duplicate4instance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, snd, m);
		}
	}
	return retVal___;
}
void HP_npc_setcells(struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_setcells_pre ) {
		void (*preHookFunc) (struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.setcells(nd);
	}
	if( HPMHooks.count.HP_npc_setcells_post ) {
		void (*postHookFunc) (struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setcells_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_setcells_post[hIndex].func;
			postHookFunc(nd);
		}
	}
	return;
}
int HP_npc_unsetcells_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.npc.unsetcells_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_npc_unsetcells_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_npc_unsetcells_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_npc_unsetcells(struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_unsetcells_pre ) {
		void (*preHookFunc) (struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.unsetcells(nd);
	}
	if( HPMHooks.count.HP_npc_unsetcells_post ) {
		void (*postHookFunc) (struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unsetcells_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_unsetcells_post[hIndex].func;
			postHookFunc(nd);
		}
	}
	return;
}
void HP_npc_movenpc(struct npc_data *nd, int16 x, int16 y) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_movenpc_pre ) {
		void (*preHookFunc) (struct npc_data **nd, int16 *x, int16 *y);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.movenpc(nd, x, y);
	}
	if( HPMHooks.count.HP_npc_movenpc_post ) {
		void (*postHookFunc) (struct npc_data *nd, int16 x, int16 y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_movenpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_movenpc_post[hIndex].func;
			postHookFunc(nd, x, y);
		}
	}
	return;
}
void HP_npc_setdisplayname(struct npc_data *nd, const char *newname) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_setdisplayname_pre ) {
		void (*preHookFunc) (struct npc_data **nd, const char **newname);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.setdisplayname(nd, newname);
	}
	if( HPMHooks.count.HP_npc_setdisplayname_post ) {
		void (*postHookFunc) (struct npc_data *nd, const char *newname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setdisplayname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_setdisplayname_post[hIndex].func;
			postHookFunc(nd, newname);
		}
	}
	return;
}
void HP_npc_setclass(struct npc_data *nd, short class_) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_setclass_pre ) {
		void (*preHookFunc) (struct npc_data **nd, short *class_);
		*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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.setclass(nd, class_);
	}
	if( HPMHooks.count.HP_npc_setclass_post ) {
		void (*postHookFunc) (struct npc_data *nd, short class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_setclass_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_setclass_post[hIndex].func;
			postHookFunc(nd, class_);
		}
	}
	return;
}
int HP_npc_do_atcmd_event(struct map_session_data *sd, const char *command, const char *message, const char *eventname) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.do_atcmd_event(sd, command, message, eventname);
	}
	if( HPMHooks.count.HP_npc_do_atcmd_event_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *command, const char *message, const char *eventname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_do_atcmd_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_do_atcmd_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, command, message, eventname);
		}
	}
	return retVal___;
}
const char* HP_npc_parse_function(const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_parse_function_pre ) {
		const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval);
		*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, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parse_function(w1, w2, w3, w4, start, buffer, filepath, retval);
	}
	if( HPMHooks.count.HP_npc_parse_function_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_function_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_function_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, retval);
		}
	}
	return retVal___;
}
void HP_npc_parse_mob2(struct spawn_data *mobspawn) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_parse_mob2_pre ) {
		void (*preHookFunc) (struct spawn_data **mobspawn);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.parse_mob2(mobspawn);
	}
	if( HPMHooks.count.HP_npc_parse_mob2_post ) {
		void (*postHookFunc) (struct spawn_data *mobspawn);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_mob2_post[hIndex].func;
			postHookFunc(mobspawn);
		}
	}
	return;
}
const char* HP_npc_parse_mob(const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_parse_mob_pre ) {
		const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval);
		*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, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parse_mob(w1, w2, w3, w4, start, buffer, filepath, retval);
	}
	if( HPMHooks.count.HP_npc_parse_mob_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mob_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_mob_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, retval);
		}
	}
	return retVal___;
}
const char* HP_npc_parse_mapflag(const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_npc_parse_mapflag_pre ) {
		const char* (*preHookFunc) (const char **w1, const char **w2, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval);
		*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, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parse_mapflag(w1, w2, w3, w4, start, buffer, filepath, retval);
	}
	if( HPMHooks.count.HP_npc_parse_mapflag_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *w1, const char *w2, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_mapflag_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_mapflag_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, w1, w2, w3, w4, start, buffer, filepath, retval);
		}
	}
	return retVal___;
}
void HP_npc_parse_unknown_mapflag(const char *name, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_parse_unknown_mapflag_pre ) {
		void (*preHookFunc) (const char **name, const char **w3, const char **w4, const char **start, const char **buffer, const char **filepath, int **retval);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_unknown_mapflag_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_parse_unknown_mapflag_pre[hIndex].func;
			preHookFunc(&name, &w3, &w4, &start, &buffer, &filepath, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.parse_unknown_mapflag(name, w3, w4, start, buffer, filepath, retval);
	}
	if( HPMHooks.count.HP_npc_parse_unknown_mapflag_post ) {
		void (*postHookFunc) (const char *name, const char *w3, const char *w4, const char *start, const char *buffer, const char *filepath, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parse_unknown_mapflag_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parse_unknown_mapflag_post[hIndex].func;
			postHookFunc(name, w3, w4, start, buffer, filepath, retval);
		}
	}
	return;
}
int HP_npc_parsesrcfile(const char *filepath, bool runOnInit) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.parsesrcfile(filepath, runOnInit);
	}
	if( HPMHooks.count.HP_npc_parsesrcfile_post ) {
		int (*postHookFunc) (int retVal___, const char *filepath, bool runOnInit);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_parsesrcfile_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_parsesrcfile_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filepath, runOnInit);
		}
	}
	return retVal___;
}
int HP_npc_script_event(struct map_session_data *sd, enum npce_event type) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.script_event(sd, type);
	}
	if( HPMHooks.count.HP_npc_script_event_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum npce_event type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_script_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_script_event_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
void HP_npc_read_event_script(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_read_event_script_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.read_event_script();
	}
	if( HPMHooks.count.HP_npc_read_event_script_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_read_event_script_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_read_event_script_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_npc_path_db_clear_sub(union DBKey key, struct DBData *data, va_list args) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_path_db_clear_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.npc.path_db_clear_sub(key, data, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_npc_path_db_clear_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_path_db_clear_sub_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_npc_path_db_clear_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_npc_ev_label_db_clear_sub(union DBKey key, struct DBData *data, va_list args) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_ev_label_db_clear_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.npc.ev_label_db_clear_sub(key, data, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_npc_ev_label_db_clear_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_ev_label_db_clear_sub_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_npc_ev_label_db_clear_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_npc_reload(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.reload();
	}
	if( HPMHooks.count.HP_npc_reload_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_reload_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_npc_unloadfile(const char *filepath) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.unloadfile(filepath);
	}
	if( HPMHooks.count.HP_npc_unloadfile_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filepath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_unloadfile_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_unloadfile_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filepath);
		}
	}
	return retVal___;
}
void HP_npc_do_clear_npc(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_do_clear_npc_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.do_clear_npc();
	}
	if( HPMHooks.count.HP_npc_do_clear_npc_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_do_clear_npc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_do_clear_npc_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_npc_debug_warps_sub(struct npc_data *nd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_debug_warps_sub_pre ) {
		void (*preHookFunc) (struct npc_data **nd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.debug_warps_sub(nd);
	}
	if( HPMHooks.count.HP_npc_debug_warps_sub_post ) {
		void (*postHookFunc) (struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_debug_warps_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_debug_warps_sub_post[hIndex].func;
			postHookFunc(nd);
		}
	}
	return;
}
void HP_npc_debug_warps(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_npc_debug_warps_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.debug_warps();
	}
	if( HPMHooks.count.HP_npc_debug_warps_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_debug_warps_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_debug_warps_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.trader_count_funds(nd, sd);
	}
	if( HPMHooks.count.HP_npc_trader_count_funds_post ) {
		void (*postHookFunc) (struct npc_data *nd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_count_funds_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_trader_count_funds_post[hIndex].func;
			postHookFunc(nd, sd);
		}
	}
	return;
}
bool HP_npc_trader_pay(struct npc_data *nd, struct map_session_data *sd, int price, int points) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.trader_pay(nd, sd, price, points);
	}
	if( HPMHooks.count.HP_npc_trader_pay_post ) {
		bool (*postHookFunc) (bool retVal___, struct npc_data *nd, struct map_session_data *sd, int price, int points);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_pay_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_trader_pay_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, sd, price, points);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.trader_update(master);
	}
	if( HPMHooks.count.HP_npc_trader_update_post ) {
		void (*postHookFunc) (int master);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_update_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_trader_update_post[hIndex].func;
			postHookFunc(master);
		}
	}
	return;
}
int HP_npc_market_buylist(struct map_session_data *sd, struct itemlist *item_list) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_npc_market_buylist_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, struct itemlist **item_list);
		*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, &item_list);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.market_buylist(sd, item_list);
	}
	if( HPMHooks.count.HP_npc_market_buylist_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct itemlist *item_list);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_buylist_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_market_buylist_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_list);
		}
	}
	return retVal___;
}
bool HP_npc_trader_open(struct map_session_data *sd, struct npc_data *nd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.trader_open(sd, nd);
	}
	if( HPMHooks.count.HP_npc_trader_open_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct npc_data *nd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_trader_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_trader_open_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nd);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.market_fromsql();
	}
	if( HPMHooks.count.HP_npc_market_fromsql_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_fromsql_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_market_fromsql_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.market_tosql(nd, index);
	}
	if( HPMHooks.count.HP_npc_market_tosql_post ) {
		void (*postHookFunc) (struct npc_data *nd, unsigned short index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_tosql_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_market_tosql_post[hIndex].func;
			postHookFunc(nd, index);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.market_delfromsql(nd, index);
	}
	if( HPMHooks.count.HP_npc_market_delfromsql_post ) {
		void (*postHookFunc) (struct npc_data *nd, unsigned short index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_delfromsql_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_market_delfromsql_post[hIndex].func;
			postHookFunc(nd, index);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.npc.market_delfromsql_sub(npcname, index);
	}
	if( HPMHooks.count.HP_npc_market_delfromsql_sub_post ) {
		void (*postHookFunc) (const char *npcname, unsigned short index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_market_delfromsql_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_market_delfromsql_sub_post[hIndex].func;
			postHookFunc(npcname, index);
		}
	}
	return;
}
bool HP_npc_db_checkid(const int id) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_npc_db_checkid_pre ) {
		bool (*preHookFunc) (const int *id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_db_checkid_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_npc_db_checkid_pre[hIndex].func;
			retVal___ = preHookFunc(&id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.db_checkid(id);
	}
	if( HPMHooks.count.HP_npc_db_checkid_post ) {
		bool (*postHookFunc) (bool retVal___, const int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_db_checkid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_db_checkid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
int HP_npc_secure_timeout_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.npc.secure_timeout_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_npc_secure_timeout_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_npc_secure_timeout_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_npc_secure_timeout_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
/* nullpo_interface */
void HP_nullpo_assert_report(const char *file, int line, const char *func, const char *targetname, const char *title) {
	int hIndex = 0;
	if( HPMHooks.count.HP_nullpo_assert_report_pre ) {
		void (*preHookFunc) (const char **file, int *line, const char **func, const char **targetname, const char **title);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_nullpo_assert_report_pre[hIndex].func;
			preHookFunc(&file, &line, &func, &targetname, &title);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.nullpo.assert_report(file, line, func, targetname, title);
	}
	if( HPMHooks.count.HP_nullpo_assert_report_post ) {
		void (*postHookFunc) (const char *file, int line, const char *func, const char *targetname, const char *title);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_nullpo_assert_report_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_nullpo_assert_report_post[hIndex].func;
			postHookFunc(file, line, func, targetname, title);
		}
	}
	return;
}
/* party_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.init(minimal);
	}
	if( HPMHooks.count.HP_party_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.final();
	}
	if( HPMHooks.count.HP_party_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct party_data* HP_party_search(int party_id) {
	int hIndex = 0;
	struct party_data* retVal___ = NULL;
	if( HPMHooks.count.HP_party_search_pre ) {
		struct party_data* (*preHookFunc) (int *party_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.search(party_id);
	}
	if( HPMHooks.count.HP_party_search_post ) {
		struct party_data* (*postHookFunc) (struct party_data* retVal___, int party_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id);
		}
	}
	return retVal___;
}
struct party_data* HP_party_searchname(const char *str) {
	int hIndex = 0;
	struct party_data* retVal___ = NULL;
	if( HPMHooks.count.HP_party_searchname_pre ) {
		struct party_data* (*preHookFunc) (const char **str);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.searchname(str);
	}
	if( HPMHooks.count.HP_party_searchname_post ) {
		struct party_data* (*postHookFunc) (struct party_data* retVal___, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_searchname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_searchname_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
int HP_party_getmemberid(struct party_data *p, struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.getmemberid(p, sd);
	}
	if( HPMHooks.count.HP_party_getmemberid_post ) {
		int (*postHookFunc) (int retVal___, struct party_data *p, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getmemberid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_getmemberid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, sd);
		}
	}
	return retVal___;
}
struct map_session_data* HP_party_getavailablesd(struct party_data *p) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_party_getavailablesd_pre ) {
		struct map_session_data* (*preHookFunc) (struct party_data **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.getavailablesd(p);
	}
	if( HPMHooks.count.HP_party_getavailablesd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct party_data *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_getavailablesd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_getavailablesd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
int HP_party_create(struct map_session_data *sd, const char *name, int item, int item2) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_party_create_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.create(sd, name, item, item2);
	}
	if( HPMHooks.count.HP_party_create_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int item, int item2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name, item, item2);
		}
	}
	return retVal___;
}
void HP_party_created(int account_id, int char_id, int fail, int party_id, const char *name) {
	int hIndex = 0;
	if( HPMHooks.count.HP_party_created_pre ) {
		void (*preHookFunc) (int *account_id, int *char_id, int *fail, int *party_id, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.created(account_id, char_id, fail, party_id, name);
	}
	if( HPMHooks.count.HP_party_created_post ) {
		void (*postHookFunc) (int account_id, int char_id, int fail, int party_id, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_created_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_created_post[hIndex].func;
			postHookFunc(account_id, char_id, fail, party_id, name);
		}
	}
	return;
}
int HP_party_request_info(int party_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.request_info(party_id, char_id);
	}
	if( HPMHooks.count.HP_party_request_info_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_request_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_request_info_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, char_id);
		}
	}
	return retVal___;
}
int HP_party_invite(struct map_session_data *sd, struct map_session_data *tsd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.invite(sd, tsd);
	}
	if( HPMHooks.count.HP_party_invite_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_invite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_invite_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, tsd);
		}
	}
	return retVal___;
}
void HP_party_member_joined(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_party_member_joined_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.member_joined(sd);
	}
	if( HPMHooks.count.HP_party_member_joined_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_joined_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_member_joined_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_party_member_added(int party_id, int account_id, int char_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.member_added(party_id, account_id, char_id, flag);
	}
	if( HPMHooks.count.HP_party_member_added_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_added_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_member_added_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, char_id, flag);
		}
	}
	return retVal___;
}
int HP_party_leave(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.leave(sd);
	}
	if( HPMHooks.count.HP_party_leave_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_leave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_leave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_party_removemember(struct map_session_data *sd, int account_id, const char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_party_removemember_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, int *account_id, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.removemember(sd, account_id, name);
	}
	if( HPMHooks.count.HP_party_removemember_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int account_id, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_removemember_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_removemember_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, account_id, name);
		}
	}
	return retVal___;
}
int HP_party_member_withdraw(int party_id, int account_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.member_withdraw(party_id, account_id, char_id);
	}
	if( HPMHooks.count.HP_party_member_withdraw_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_member_withdraw_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_member_withdraw_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, char_id);
		}
	}
	return retVal___;
}
void HP_party_reply_invite(struct map_session_data *sd, int party_id, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_party_reply_invite_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *party_id, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.reply_invite(sd, party_id, flag);
	}
	if( HPMHooks.count.HP_party_reply_invite_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int party_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_reply_invite_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_reply_invite_post[hIndex].func;
			postHookFunc(sd, party_id, flag);
		}
	}
	return;
}
int HP_party_recv_noinfo(int party_id, int char_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.recv_noinfo(party_id, char_id);
	}
	if( HPMHooks.count.HP_party_recv_noinfo_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_noinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_recv_noinfo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, char_id);
		}
	}
	return retVal___;
}
int HP_party_recv_info(const struct party *sp, int char_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_party_recv_info_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.recv_info(sp, char_id);
	}
	if( HPMHooks.count.HP_party_recv_info_post ) {
		int (*postHookFunc) (int retVal___, const struct party *sp, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_info_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_recv_info_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sp, char_id);
		}
	}
	return retVal___;
}
int HP_party_recv_movemap(int party_id, int account_id, int char_id, unsigned short mapid, int online, int lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.recv_movemap(party_id, account_id, char_id, mapid, online, lv);
	}
	if( HPMHooks.count.HP_party_recv_movemap_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, int char_id, unsigned short mapid, int online, int lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_movemap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_recv_movemap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, char_id, mapid, online, lv);
		}
	}
	return retVal___;
}
int HP_party_broken(int party_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.broken(party_id);
	}
	if( HPMHooks.count.HP_party_broken_post ) {
		int (*postHookFunc) (int retVal___, int party_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_broken_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_broken_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id);
		}
	}
	return retVal___;
}
int HP_party_optionchanged(int party_id, int account_id, int exp, int item, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.optionchanged(party_id, account_id, exp, item, flag);
	}
	if( HPMHooks.count.HP_party_optionchanged_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, int exp, int item, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_optionchanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_optionchanged_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, exp, item, flag);
		}
	}
	return retVal___;
}
int HP_party_changeoption(struct map_session_data *sd, int exp, int item) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.changeoption(sd, exp, item);
	}
	if( HPMHooks.count.HP_party_changeoption_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int exp, int item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeoption_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_changeoption_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, exp, item);
		}
	}
	return retVal___;
}
bool HP_party_changeleader(struct map_session_data *sd, struct map_session_data *t_sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.changeleader(sd, t_sd);
	}
	if( HPMHooks.count.HP_party_changeleader_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct map_session_data *t_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_changeleader_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_changeleader_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, t_sd);
		}
	}
	return retVal___;
}
void HP_party_send_movemap(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_party_send_movemap_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.send_movemap(sd);
	}
	if( HPMHooks.count.HP_party_send_movemap_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_movemap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_send_movemap_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_party_send_levelup(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_party_send_levelup_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.send_levelup(sd);
	}
	if( HPMHooks.count.HP_party_send_levelup_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_levelup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_send_levelup_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_party_send_logout(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.send_logout(sd);
	}
	if( HPMHooks.count.HP_party_send_logout_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_logout_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_send_logout_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_party_send_message(struct map_session_data *sd, const char *mes) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_party_send_message_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const char **mes);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.send_message(sd, mes);
	}
	if( HPMHooks.count.HP_party_send_message_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *mes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_send_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, mes);
		}
	}
	return retVal___;
}
int HP_party_recv_message(int party_id, int account_id, const char *mes, int len) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.recv_message(party_id, account_id, mes, len);
	}
	if( HPMHooks.count.HP_party_recv_message_post ) {
		int (*postHookFunc) (int retVal___, int party_id, int account_id, const char *mes, int len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recv_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_recv_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, mes, len);
		}
	}
	return retVal___;
}
int HP_party_skill_check(struct map_session_data *sd, int party_id, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.skill_check(sd, party_id, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_party_skill_check_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int party_id, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_skill_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_skill_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, party_id, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_party_send_xy_clear(struct party_data *p) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.send_xy_clear(p);
	}
	if( HPMHooks.count.HP_party_send_xy_clear_post ) {
		int (*postHookFunc) (int retVal___, struct party_data *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_xy_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_send_xy_clear_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
int HP_party_exp_share(struct party_data *p, struct block_list *src, unsigned int base_exp, unsigned int job_exp, int zeny) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.exp_share(p, src, base_exp, job_exp, zeny);
	}
	if( HPMHooks.count.HP_party_exp_share_post ) {
		int (*postHookFunc) (int retVal___, struct party_data *p, struct block_list *src, unsigned int base_exp, unsigned int job_exp, int zeny);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_exp_share_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_exp_share_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, src, base_exp, job_exp, zeny);
		}
	}
	return retVal___;
}
int HP_party_share_loot(struct party_data *p, struct map_session_data *sd, struct item *item_data, int first_charid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.share_loot(p, sd, item_data, first_charid);
	}
	if( HPMHooks.count.HP_party_share_loot_post ) {
		int (*postHookFunc) (int retVal___, struct party_data *p, struct map_session_data *sd, struct item *item_data, int first_charid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_share_loot_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_share_loot_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, sd, item_data, first_charid);
		}
	}
	return retVal___;
}
int HP_party_send_dot_remove(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.send_dot_remove(sd);
	}
	if( HPMHooks.count.HP_party_send_dot_remove_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_dot_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_send_dot_remove_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_party_sub_count(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.party.sub_count(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_party_sub_count_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sub_count_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_party_sub_count_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_party_sub_count_chorus(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.party.sub_count_chorus(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_party_sub_count_chorus_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sub_count_chorus_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_party_sub_count_chorus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_party_booking_register(struct map_session_data *sd, short level, short mapid, short *job) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.booking_register(sd, level, mapid, job);
	}
	if( HPMHooks.count.HP_party_booking_register_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short level, short mapid, short *job);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_register_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_booking_register_post[hIndex].func;
			postHookFunc(sd, level, mapid, job);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.booking_update(sd, job);
	}
	if( HPMHooks.count.HP_party_booking_update_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short *job);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_update_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_booking_update_post[hIndex].func;
			postHookFunc(sd, job);
		}
	}
	return;
}
void HP_party_booking_search(struct map_session_data *sd, short level, short mapid, short job, unsigned long lastindex, short resultcount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_party_booking_search_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *level, short *mapid, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.booking_search(sd, level, mapid, job, lastindex, resultcount);
	}
	if( HPMHooks.count.HP_party_booking_search_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short level, short mapid, short job, unsigned long lastindex, short resultcount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_booking_search_post[hIndex].func;
			postHookFunc(sd, level, mapid, job, lastindex, resultcount);
		}
	}
	return;
}
void HP_party_recruit_register(struct map_session_data *sd, short level, const char *notice) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.recruit_register(sd, level, notice);
	}
	if( HPMHooks.count.HP_party_recruit_register_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short level, const char *notice);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_register_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_recruit_register_post[hIndex].func;
			postHookFunc(sd, level, notice);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.recruit_update(sd, notice);
	}
	if( HPMHooks.count.HP_party_recruit_update_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *notice);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_update_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_recruit_update_post[hIndex].func;
			postHookFunc(sd, notice);
		}
	}
	return;
}
void HP_party_recruit_search(struct map_session_data *sd, short level, short mapid, unsigned long lastindex, short resultcount) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.recruit_search(sd, level, mapid, lastindex, resultcount);
	}
	if( HPMHooks.count.HP_party_recruit_search_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short level, short mapid, unsigned long lastindex, short resultcount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_recruit_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_recruit_search_post[hIndex].func;
			postHookFunc(sd, level, mapid, lastindex, resultcount);
		}
	}
	return;
}
bool HP_party_booking_delete(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.booking_delete(sd);
	}
	if( HPMHooks.count.HP_party_booking_delete_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_booking_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_booking_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_party_vforeachsamemap(int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int range, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&func, &sd, &range, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.party.vforeachsamemap(func, sd, range, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_party_vforeachsamemap_post ) {
		int (*postHookFunc) (int retVal___, int ( *func ) (struct block_list *, va_list), struct map_session_data *sd, int range, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_vforeachsamemap_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_party_vforeachsamemap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, sd, range, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_party_send_xy_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.send_xy_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_party_send_xy_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_send_xy_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_send_xy_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_party_fill_member(struct party_member *member, struct map_session_data *sd, unsigned int leader) {
	int hIndex = 0;
	if( HPMHooks.count.HP_party_fill_member_pre ) {
		void (*preHookFunc) (struct party_member **member, struct map_session_data **sd, unsigned int *leader);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.fill_member(member, sd, leader);
	}
	if( HPMHooks.count.HP_party_fill_member_post ) {
		void (*postHookFunc) (struct party_member *member, struct map_session_data *sd, unsigned int leader);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_fill_member_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_fill_member_post[hIndex].func;
			postHookFunc(member, sd, leader);
		}
	}
	return;
}
struct map_session_data* HP_party_sd_check(int party_id, int account_id, int char_id) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_party_sd_check_pre ) {
		struct map_session_data* (*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.sd_check(party_id, account_id, char_id);
	}
	if( HPMHooks.count.HP_party_sd_check_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, int party_id, int account_id, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_sd_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_sd_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, party_id, account_id, char_id);
		}
	}
	return retVal___;
}
void HP_party_check_state(struct party_data *p) {
	int hIndex = 0;
	if( HPMHooks.count.HP_party_check_state_pre ) {
		void (*preHookFunc) (struct party_data **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.party.check_state(p);
	}
	if( HPMHooks.count.HP_party_check_state_post ) {
		void (*postHookFunc) (struct party_data *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_check_state_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_check_state_post[hIndex].func;
			postHookFunc(p);
		}
	}
	return;
}
struct party_booking_ad_info* HP_party_create_booking_data(void) {
	int hIndex = 0;
	struct party_booking_ad_info* retVal___ = NULL;
	if( HPMHooks.count.HP_party_create_booking_data_pre ) {
		struct party_booking_ad_info* (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.party.create_booking_data();
	}
	if( HPMHooks.count.HP_party_create_booking_data_post ) {
		struct party_booking_ad_info* (*postHookFunc) (struct party_booking_ad_info* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_create_booking_data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_party_create_booking_data_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_party_db_final(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_party_db_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.party.db_final(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_party_db_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_party_db_final_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_party_db_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
/* path_interface */
int HP_path_blownpos(struct block_list *bl, int16 m, int16 x0, int16 y0, int16 dx, int16 dy, int count) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_path_blownpos_pre ) {
		int (*preHookFunc) (struct block_list **bl, 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(&bl, &m, &x0, &y0, &dx, &dy, &count);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.path.blownpos(bl, m, x0, y0, dx, dy, count);
	}
	if( HPMHooks.count.HP_path_blownpos_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 dx, int16 dy, int count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_blownpos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_path_blownpos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, m, x0, y0, dx, dy, count);
		}
	}
	return retVal___;
}
bool HP_path_search(struct walkpath_data *wpd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int flag, cell_chk cell) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_path_search_pre ) {
		bool (*preHookFunc) (struct walkpath_data **wpd, struct block_list **bl, 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, &bl, &m, &x0, &y0, &x1, &y1, &flag, &cell);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.path.search(wpd, bl, m, x0, y0, x1, y1, flag, cell);
	}
	if( HPMHooks.count.HP_path_search_post ) {
		bool (*postHookFunc) (bool retVal___, struct walkpath_data *wpd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, int flag, cell_chk cell);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_path_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, wpd, bl, m, x0, y0, x1, y1, flag, cell);
		}
	}
	return retVal___;
}
bool HP_path_search_long(struct shootpath_data *spd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, cell_chk cell) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_path_search_long_pre ) {
		bool (*preHookFunc) (struct shootpath_data **spd, struct block_list **bl, 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, &bl, &m, &x0, &y0, &x1, &y1, &cell);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.path.search_long(spd, bl, m, x0, y0, x1, y1, cell);
	}
	if( HPMHooks.count.HP_path_search_long_post ) {
		bool (*postHookFunc) (bool retVal___, struct shootpath_data *spd, struct block_list *bl, int16 m, int16 x0, int16 y0, int16 x1, int16 y1, cell_chk cell);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_search_long_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_path_search_long_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, spd, bl, m, x0, y0, x1, y1, cell);
		}
	}
	return retVal___;
}
bool HP_path_check_distance(int dx, int dy, int distance) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_path_check_distance_pre ) {
		bool (*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.path.check_distance(dx, dy, distance);
	}
	if( HPMHooks.count.HP_path_check_distance_post ) {
		bool (*postHookFunc) (bool retVal___, int dx, int dy, int distance);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_check_distance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_path_check_distance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, dx, dy, distance);
		}
	}
	return retVal___;
}
unsigned int HP_path_distance(int dx, int dy) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.path.distance(dx, dy);
	}
	if( HPMHooks.count.HP_path_distance_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, int dx, int dy);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_distance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_path_distance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, dx, dy);
		}
	}
	return retVal___;
}
bool HP_path_check_distance_client(int dx, int dy, int distance) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_path_check_distance_client_pre ) {
		bool (*preHookFunc) (int *dx, int *dy, int *distance);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_check_distance_client_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_path_check_distance_client_pre[hIndex].func;
			retVal___ = preHookFunc(&dx, &dy, &distance);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.path.check_distance_client(dx, dy, distance);
	}
	if( HPMHooks.count.HP_path_check_distance_client_post ) {
		bool (*postHookFunc) (bool retVal___, int dx, int dy, int distance);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_check_distance_client_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_path_check_distance_client_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, dx, dy, distance);
		}
	}
	return retVal___;
}
int HP_path_distance_client(int dx, int dy) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_path_distance_client_pre ) {
		int (*preHookFunc) (int *dx, int *dy);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_distance_client_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_path_distance_client_pre[hIndex].func;
			retVal___ = preHookFunc(&dx, &dy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.path.distance_client(dx, dy);
	}
	if( HPMHooks.count.HP_path_distance_client_post ) {
		int (*postHookFunc) (int retVal___, int dx, int dy);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_path_distance_client_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_path_distance_client_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, dx, dy);
		}
	}
	return retVal___;
}
/* pc_groups_interface */
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pcg.init();
	}
	if( HPMHooks.count.HP_pcg_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pcg.final();
	}
	if( HPMHooks.count.HP_pcg_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pcg.reload();
	}
	if( HPMHooks.count.HP_pcg_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
GroupSettings* HP_pcg_get_dummy_group(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pcg.get_dummy_group();
	}
	if( HPMHooks.count.HP_pcg_get_dummy_group_post ) {
		GroupSettings* (*postHookFunc) (GroupSettings* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_dummy_group_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_get_dummy_group_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_pcg_exists(int group_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pcg.exists(group_id);
	}
	if( HPMHooks.count.HP_pcg_exists_post ) {
		bool (*postHookFunc) (bool retVal___, int group_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_exists_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_exists_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group_id);
		}
	}
	return retVal___;
}
GroupSettings* HP_pcg_id2group(int group_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pcg.id2group(group_id);
	}
	if( HPMHooks.count.HP_pcg_id2group_post ) {
		GroupSettings* (*postHookFunc) (GroupSettings* retVal___, int group_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_id2group_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_id2group_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group_id);
		}
	}
	return retVal___;
}
bool HP_pcg_has_permission(GroupSettings *group, unsigned int permission) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pcg.has_permission(group, permission);
	}
	if( HPMHooks.count.HP_pcg_has_permission_post ) {
		bool (*postHookFunc) (bool retVal___, GroupSettings *group, unsigned int permission);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_has_permission_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_has_permission_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group, permission);
		}
	}
	return retVal___;
}
bool HP_pcg_should_log_commands(GroupSettings *group) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pcg.should_log_commands(group);
	}
	if( HPMHooks.count.HP_pcg_should_log_commands_post ) {
		bool (*postHookFunc) (bool retVal___, GroupSettings *group);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_should_log_commands_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_should_log_commands_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group);
		}
	}
	return retVal___;
}
const char* HP_pcg_get_name(GroupSettings *group) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pcg.get_name(group);
	}
	if( HPMHooks.count.HP_pcg_get_name_post ) {
		const char* (*postHookFunc) (const char* retVal___, GroupSettings *group);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_get_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group);
		}
	}
	return retVal___;
}
int HP_pcg_get_level(GroupSettings *group) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pcg.get_level(group);
	}
	if( HPMHooks.count.HP_pcg_get_level_post ) {
		int (*postHookFunc) (int retVal___, GroupSettings *group);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_level_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_get_level_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group);
		}
	}
	return retVal___;
}
int HP_pcg_get_idx(GroupSettings *group) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pcg.get_idx(group);
	}
	if( HPMHooks.count.HP_pcg_get_idx_post ) {
		int (*postHookFunc) (int retVal___, GroupSettings *group);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pcg_get_idx_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pcg_get_idx_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group);
		}
	}
	return retVal___;
}
/* pc_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.init(minimal);
	}
	if( HPMHooks.count.HP_pc_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.final();
	}
	if( HPMHooks.count.HP_pc_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct map_session_data* HP_pc_get_dummy_sd(void) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_pc_get_dummy_sd_pre ) {
		struct map_session_data* (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.get_dummy_sd();
	}
	if( HPMHooks.count.HP_pc_get_dummy_sd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_dummy_sd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_get_dummy_sd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_pc_class2idx(int class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.class2idx(class_);
	}
	if( HPMHooks.count.HP_pc_class2idx_post ) {
		int (*postHookFunc) (int retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_class2idx_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_class2idx_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
bool HP_pc_can_talk(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_pc_can_talk_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_talk_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_can_talk_pre[hIndex].func;
			retVal___ = preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.can_talk(sd);
	}
	if( HPMHooks.count.HP_pc_can_talk_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_talk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_can_talk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
bool HP_pc_can_attack(struct map_session_data *sd, int target_id) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_pc_can_attack_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, int *target_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_attack_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_can_attack_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &target_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.can_attack(sd, target_id);
	}
	if( HPMHooks.count.HP_pc_can_attack_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int target_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_can_attack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, target_id);
		}
	}
	return retVal___;
}
bool HP_pc_can_use_command(struct map_session_data *sd, const char *command) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.can_use_command(sd, command);
	}
	if( HPMHooks.count.HP_pc_can_use_command_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *command);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_use_command_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_can_use_command_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, command);
		}
	}
	return retVal___;
}
int HP_pc_set_group(struct map_session_data *sd, int group_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.set_group(sd, group_id);
	}
	if( HPMHooks.count.HP_pc_set_group_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int group_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_group_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_set_group_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, group_id);
		}
	}
	return retVal___;
}
bool HP_pc_should_log_commands(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.should_log_commands(sd);
	}
	if( HPMHooks.count.HP_pc_should_log_commands_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_should_log_commands_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_should_log_commands_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_setrestartvalue(struct map_session_data *sd, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setrestartvalue(sd, type);
	}
	if( HPMHooks.count.HP_pc_setrestartvalue_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setrestartvalue_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setrestartvalue_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
int HP_pc_makesavestatus(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.makesavestatus(sd);
	}
	if( HPMHooks.count.HP_pc_makesavestatus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_makesavestatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_makesavestatus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_pc_respawn(struct map_session_data *sd, clr_type clrtype) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_respawn_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, clr_type *clrtype);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.respawn(sd, clrtype);
	}
	if( HPMHooks.count.HP_pc_respawn_post ) {
		void (*postHookFunc) (struct map_session_data *sd, clr_type clrtype);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_respawn_post[hIndex].func;
			postHookFunc(sd, clrtype);
		}
	}
	return;
}
int HP_pc_setnewpc(struct map_session_data *sd, int account_id, int char_id, int login_id1, unsigned int client_tick, int sex, int fd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setnewpc(sd, account_id, char_id, login_id1, client_tick, sex, fd);
	}
	if( HPMHooks.count.HP_pc_setnewpc_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int account_id, int char_id, int login_id1, unsigned int client_tick, int sex, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setnewpc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setnewpc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, account_id, char_id, login_id1, client_tick, sex, fd);
		}
	}
	return retVal___;
}
bool HP_pc_authok(struct map_session_data *sd, int login_id2, time_t expiration_time, int group_id, const struct mmo_charstatus *st, bool changing_mapservers) {
	int hIndex = 0;
	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, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.authok(sd, login_id2, expiration_time, group_id, st, changing_mapservers);
	}
	if( HPMHooks.count.HP_pc_authok_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int login_id2, time_t expiration_time, int group_id, const struct mmo_charstatus *st, bool changing_mapservers);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_authok_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, login_id2, expiration_time, group_id, st, changing_mapservers);
		}
	}
	return retVal___;
}
void HP_pc_authfail(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_authfail_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.authfail(sd);
	}
	if( HPMHooks.count.HP_pc_authfail_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_authfail_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_authfail_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_pc_reg_received(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.reg_received(sd);
	}
	if( HPMHooks.count.HP_pc_reg_received_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_reg_received_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_reg_received_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_isequip(struct map_session_data *sd, int n) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.isequip(sd, n);
	}
	if( HPMHooks.count.HP_pc_isequip_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_isequip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n);
		}
	}
	return retVal___;
}
int HP_pc_equippoint(struct map_session_data *sd, int n) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.equippoint(sd, n);
	}
	if( HPMHooks.count.HP_pc_equippoint_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equippoint_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_equippoint_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n);
		}
	}
	return retVal___;
}
int HP_pc_setinventorydata(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setinventorydata(sd);
	}
	if( HPMHooks.count.HP_pc_setinventorydata_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinventorydata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setinventorydata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_checkskill(struct map_session_data *sd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkskill(sd, skill_id);
	}
	if( HPMHooks.count.HP_pc_checkskill_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
int HP_pc_checkskill2(struct map_session_data *sd, uint16 index) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkskill2(sd, index);
	}
	if( HPMHooks.count.HP_pc_checkskill2_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkskill2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkskill2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index);
		}
	}
	return retVal___;
}
int HP_pc_checkallowskill(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkallowskill(sd);
	}
	if( HPMHooks.count.HP_pc_checkallowskill_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkallowskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkallowskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_checkequip(struct map_session_data *sd, int pos) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkequip(sd, pos);
	}
	if( HPMHooks.count.HP_pc_checkequip_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkequip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkequip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, pos);
		}
	}
	return retVal___;
}
int HP_pc_calc_skilltree(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.calc_skilltree(sd);
	}
	if( HPMHooks.count.HP_pc_calc_skilltree_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_calc_skilltree_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_calc_skilltree_normalize_job(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.calc_skilltree_normalize_job(sd);
	}
	if( HPMHooks.count.HP_pc_calc_skilltree_normalize_job_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skilltree_normalize_job_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_calc_skilltree_normalize_job_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_clean_skilltree(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.clean_skilltree(sd);
	}
	if( HPMHooks.count.HP_pc_clean_skilltree_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_clean_skilltree_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_clean_skilltree_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_setpos(struct map_session_data *sd, unsigned short map_index, int x, int y, clr_type clrtype) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setpos(sd, map_index, x, y, clrtype);
	}
	if( HPMHooks.count.HP_pc_setpos_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, unsigned short map_index, int x, int y, clr_type clrtype);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setpos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setpos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, map_index, x, y, clrtype);
		}
	}
	return retVal___;
}
int HP_pc_setsavepoint(struct map_session_data *sd, short map_index, int x, int y) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setsavepoint(sd, map_index, x, y);
	}
	if( HPMHooks.count.HP_pc_setsavepoint_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, short map_index, int x, int y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setsavepoint_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setsavepoint_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, map_index, x, y);
		}
	}
	return retVal___;
}
int HP_pc_randomwarp(struct map_session_data *sd, clr_type type) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.randomwarp(sd, type);
	}
	if( HPMHooks.count.HP_pc_randomwarp_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, clr_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_randomwarp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_randomwarp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
int HP_pc_memo(struct map_session_data *sd, int pos) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.memo(sd, pos);
	}
	if( HPMHooks.count.HP_pc_memo_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_memo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_memo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, pos);
		}
	}
	return retVal___;
}
int HP_pc_checkadditem(struct map_session_data *sd, int nameid, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkadditem(sd, nameid, amount);
	}
	if( HPMHooks.count.HP_pc_checkadditem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkadditem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkadditem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid, amount);
		}
	}
	return retVal___;
}
int HP_pc_inventoryblank(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.inventoryblank(sd);
	}
	if( HPMHooks.count.HP_pc_inventoryblank_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventoryblank_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_inventoryblank_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_search_inventory(struct map_session_data *sd, int item_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.search_inventory(sd, item_id);
	}
	if( HPMHooks.count.HP_pc_search_inventory_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int item_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_search_inventory_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_search_inventory_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_id);
		}
	}
	return retVal___;
}
int HP_pc_payzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.payzeny(sd, zeny, type, tsd);
	}
	if( HPMHooks.count.HP_pc_payzeny_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_payzeny_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_payzeny_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, zeny, type, tsd);
		}
	}
	return retVal___;
}
int HP_pc_additem(struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.additem(sd, item_data, amount, log_type);
	}
	if( HPMHooks.count.HP_pc_additem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_additem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_additem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_data, amount, log_type);
		}
	}
	return retVal___;
}
int HP_pc_getzeny(struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.getzeny(sd, zeny, type, tsd);
	}
	if( HPMHooks.count.HP_pc_getzeny_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int zeny, enum e_log_pick_type type, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getzeny_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_getzeny_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, zeny, type, tsd);
		}
	}
	return retVal___;
}
int HP_pc_delitem(struct map_session_data *sd, int n, int amount, int type, short reason, e_log_pick_type log_type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.delitem(sd, n, amount, type, reason, log_type);
	}
	if( HPMHooks.count.HP_pc_delitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int amount, int type, short reason, e_log_pick_type log_type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_delitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n, amount, type, reason, log_type);
		}
	}
	return retVal___;
}
int HP_pc_paycash(struct map_session_data *sd, int price, int points) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.paycash(sd, price, points);
	}
	if( HPMHooks.count.HP_pc_paycash_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int price, int points);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_paycash_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_paycash_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, price, points);
		}
	}
	return retVal___;
}
int HP_pc_getcash(struct map_session_data *sd, int cash, int points) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.getcash(sd, cash, points);
	}
	if( HPMHooks.count.HP_pc_getcash_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int cash, int points);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getcash_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_getcash_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, cash, points);
		}
	}
	return retVal___;
}
int HP_pc_cart_additem(struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.cart_additem(sd, item_data, amount, log_type);
	}
	if( HPMHooks.count.HP_pc_cart_additem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount, e_log_pick_type log_type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_additem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_cart_additem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_data, amount, log_type);
		}
	}
	return retVal___;
}
int HP_pc_cart_delitem(struct map_session_data *sd, int n, int amount, int type, e_log_pick_type log_type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.cart_delitem(sd, n, amount, type, log_type);
	}
	if( HPMHooks.count.HP_pc_cart_delitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int amount, int type, e_log_pick_type log_type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cart_delitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_cart_delitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n, amount, type, log_type);
		}
	}
	return retVal___;
}
int HP_pc_putitemtocart(struct map_session_data *sd, int idx, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.putitemtocart(sd, idx, amount);
	}
	if( HPMHooks.count.HP_pc_putitemtocart_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int idx, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_putitemtocart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_putitemtocart_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, idx, amount);
		}
	}
	return retVal___;
}
int HP_pc_getitemfromcart(struct map_session_data *sd, int idx, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.getitemfromcart(sd, idx, amount);
	}
	if( HPMHooks.count.HP_pc_getitemfromcart_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int idx, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getitemfromcart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_getitemfromcart_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, idx, amount);
		}
	}
	return retVal___;
}
int HP_pc_cartitem_amount(struct map_session_data *sd, int idx, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.cartitem_amount(sd, idx, amount);
	}
	if( HPMHooks.count.HP_pc_cartitem_amount_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int idx, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cartitem_amount_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_cartitem_amount_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, idx, amount);
		}
	}
	return retVal___;
}
int HP_pc_takeitem(struct map_session_data *sd, struct flooritem_data *fitem) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.takeitem(sd, fitem);
	}
	if( HPMHooks.count.HP_pc_takeitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct flooritem_data *fitem);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_takeitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_takeitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, fitem);
		}
	}
	return retVal___;
}
int HP_pc_dropitem(struct map_session_data *sd, int n, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.dropitem(sd, n, amount);
	}
	if( HPMHooks.count.HP_pc_dropitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dropitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_dropitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n, amount);
		}
	}
	return retVal___;
}
bool HP_pc_isequipped(struct map_session_data *sd, int nameid) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.isequipped(sd, nameid);
	}
	if( HPMHooks.count.HP_pc_isequipped_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isequipped_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_isequipped_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid);
		}
	}
	return retVal___;
}
bool HP_pc_can_Adopt(struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.can_Adopt(p1_sd, p2_sd, b_sd);
	}
	if( HPMHooks.count.HP_pc_can_Adopt_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_Adopt_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_can_Adopt_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p1_sd, p2_sd, b_sd);
		}
	}
	return retVal___;
}
bool HP_pc_adoption(struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.adoption(p1_sd, p2_sd, b_sd);
	}
	if( HPMHooks.count.HP_pc_adoption_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *p1_sd, struct map_session_data *p2_sd, struct map_session_data *b_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_adoption_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_adoption_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p1_sd, p2_sd, b_sd);
		}
	}
	return retVal___;
}
int HP_pc_updateweightstatus(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.updateweightstatus(sd);
	}
	if( HPMHooks.count.HP_pc_updateweightstatus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_updateweightstatus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_updateweightstatus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_addautobonus(struct s_autobonus *bonus, char max, const char *bonus_script, short rate, unsigned int dur, short atk_type, const char *o_script, unsigned short pos, bool onskill) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.addautobonus(bonus, max, bonus_script, rate, dur, atk_type, o_script, pos, onskill);
	}
	if( HPMHooks.count.HP_pc_addautobonus_post ) {
		int (*postHookFunc) (int retVal___, struct s_autobonus *bonus, char max, const char *bonus_script, short rate, unsigned int dur, short atk_type, const char *o_script, unsigned short pos, bool onskill);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addautobonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_addautobonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bonus, max, bonus_script, rate, dur, atk_type, o_script, pos, onskill);
		}
	}
	return retVal___;
}
int HP_pc_exeautobonus(struct map_session_data *sd, struct s_autobonus *bonus) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.exeautobonus(sd, bonus);
	}
	if( HPMHooks.count.HP_pc_exeautobonus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_autobonus *bonus);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_exeautobonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_exeautobonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, bonus);
		}
	}
	return retVal___;
}
int HP_pc_endautobonus(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.endautobonus(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_endautobonus_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_endautobonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_endautobonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_delautobonus(struct map_session_data *sd, struct s_autobonus *bonus, char max, bool restore) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.delautobonus(sd, bonus, max, restore);
	}
	if( HPMHooks.count.HP_pc_delautobonus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_autobonus *bonus, char max, bool restore);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delautobonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_delautobonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, bonus, max, restore);
		}
	}
	return retVal___;
}
int HP_pc_bonus(struct map_session_data *sd, int type, int val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus(sd, type, val);
	}
	if( HPMHooks.count.HP_pc_bonus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, val);
		}
	}
	return retVal___;
}
int HP_pc_bonus2(struct map_session_data *sd, int type, int type2, int val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus2(sd, type, type2, val);
	}
	if( HPMHooks.count.HP_pc_bonus2_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int type2, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, type2, val);
		}
	}
	return retVal___;
}
int HP_pc_bonus3(struct map_session_data *sd, int type, int type2, int type3, int val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus3(sd, type, type2, type3, val);
	}
	if( HPMHooks.count.HP_pc_bonus3_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus3_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus3_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, type2, type3, val);
		}
	}
	return retVal___;
}
int HP_pc_bonus4(struct map_session_data *sd, int type, int type2, int type3, int type4, int val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus4(sd, type, type2, type3, type4, val);
	}
	if( HPMHooks.count.HP_pc_bonus4_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int type4, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus4_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus4_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, type2, type3, type4, val);
		}
	}
	return retVal___;
}
int HP_pc_bonus5(struct map_session_data *sd, int type, int type2, int type3, int type4, int type5, int val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus5(sd, type, type2, type3, type4, type5, val);
	}
	if( HPMHooks.count.HP_pc_bonus5_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int type2, int type3, int type4, int type5, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus5_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus5_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, type2, type3, type4, type5, val);
		}
	}
	return retVal___;
}
int HP_pc_skill(struct map_session_data *sd, int id, int level, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.skill(sd, id, level, flag);
	}
	if( HPMHooks.count.HP_pc_skill_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int id, int level, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_skill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, id, level, flag);
		}
	}
	return retVal___;
}
int HP_pc_insert_card(struct map_session_data *sd, int idx_card, int idx_equip) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.insert_card(sd, idx_card, idx_equip);
	}
	if( HPMHooks.count.HP_pc_insert_card_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int idx_card, int idx_equip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_insert_card_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_insert_card_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, idx_card, idx_equip);
		}
	}
	return retVal___;
}
bool HP_pc_can_insert_card(struct map_session_data *sd, int idx_card) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_pc_can_insert_card_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, int *idx_card);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_insert_card_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_can_insert_card_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &idx_card);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.can_insert_card(sd, idx_card);
	}
	if( HPMHooks.count.HP_pc_can_insert_card_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int idx_card);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_insert_card_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_can_insert_card_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, idx_card);
		}
	}
	return retVal___;
}
bool HP_pc_can_insert_card_into(struct map_session_data *sd, int idx_card, int idx_equip) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_pc_can_insert_card_into_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, int *idx_card, int *idx_equip);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_insert_card_into_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_can_insert_card_into_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &idx_card, &idx_equip);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.can_insert_card_into(sd, idx_card, idx_equip);
	}
	if( HPMHooks.count.HP_pc_can_insert_card_into_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int idx_card, int idx_equip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_can_insert_card_into_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_can_insert_card_into_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, idx_card, idx_equip);
		}
	}
	return retVal___;
}
int HP_pc_steal_item(struct map_session_data *sd, struct block_list *bl, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.steal_item(sd, bl, skill_lv);
	}
	if( HPMHooks.count.HP_pc_steal_item_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_steal_item_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, bl, skill_lv);
		}
	}
	return retVal___;
}
int HP_pc_steal_coin(struct map_session_data *sd, struct block_list *bl, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_steal_coin_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_coin_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_steal_coin_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &bl, &skill_lv);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.steal_coin(sd, bl, skill_lv);
	}
	if( HPMHooks.count.HP_pc_steal_coin_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_steal_coin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_steal_coin_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, bl, skill_lv);
		}
	}
	return retVal___;
}
int HP_pc_modifybuyvalue(struct map_session_data *sd, int orig_value) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.modifybuyvalue(sd, orig_value);
	}
	if( HPMHooks.count.HP_pc_modifybuyvalue_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int orig_value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifybuyvalue_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_modifybuyvalue_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, orig_value);
		}
	}
	return retVal___;
}
int HP_pc_modifysellvalue(struct map_session_data *sd, int orig_value) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.modifysellvalue(sd, orig_value);
	}
	if( HPMHooks.count.HP_pc_modifysellvalue_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int orig_value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_modifysellvalue_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_modifysellvalue_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, orig_value);
		}
	}
	return retVal___;
}
int HP_pc_follow(struct map_session_data *sd, int target_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.follow(sd, target_id);
	}
	if( HPMHooks.count.HP_pc_follow_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int target_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_follow_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, target_id);
		}
	}
	return retVal___;
}
int HP_pc_stop_following(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.stop_following(sd);
	}
	if( HPMHooks.count.HP_pc_stop_following_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_stop_following_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_stop_following_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_maxbaselv(const struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_maxbaselv_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.maxbaselv(sd);
	}
	if( HPMHooks.count.HP_pc_maxbaselv_post ) {
		int (*postHookFunc) (int retVal___, const struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxbaselv_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_maxbaselv_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_maxjoblv(const struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_maxjoblv_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.maxjoblv(sd);
	}
	if( HPMHooks.count.HP_pc_maxjoblv_post ) {
		int (*postHookFunc) (int retVal___, const struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxjoblv_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_maxjoblv_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_checkbaselevelup(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkbaselevelup(sd);
	}
	if( HPMHooks.count.HP_pc_checkbaselevelup_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkbaselevelup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkbaselevelup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_checkjoblevelup(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkjoblevelup(sd);
	}
	if( HPMHooks.count.HP_pc_checkjoblevelup_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkjoblevelup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkjoblevelup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
bool HP_pc_gainexp(struct map_session_data *sd, struct block_list *src, unsigned int base_exp, unsigned int job_exp, bool is_quest) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_pc_gainexp_pre ) {
		bool (*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.gainexp(sd, src, base_exp, job_exp, is_quest);
	}
	if( HPMHooks.count.HP_pc_gainexp_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct block_list *src, unsigned int base_exp, unsigned int job_exp, bool is_quest);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gainexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_gainexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, src, base_exp, job_exp, is_quest);
		}
	}
	return retVal___;
}
unsigned int HP_pc_nextbaseexp(const struct map_session_data *sd) {
	int hIndex = 0;
	unsigned int retVal___ = 0;
	if( HPMHooks.count.HP_pc_nextbaseexp_pre ) {
		unsigned int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.nextbaseexp(sd);
	}
	if( HPMHooks.count.HP_pc_nextbaseexp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, const struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextbaseexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_nextbaseexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
unsigned int HP_pc_thisbaseexp(const struct map_session_data *sd) {
	int hIndex = 0;
	unsigned int retVal___ = 0;
	if( HPMHooks.count.HP_pc_thisbaseexp_pre ) {
		unsigned int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.thisbaseexp(sd);
	}
	if( HPMHooks.count.HP_pc_thisbaseexp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, const struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisbaseexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_thisbaseexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
unsigned int HP_pc_nextjobexp(const struct map_session_data *sd) {
	int hIndex = 0;
	unsigned int retVal___ = 0;
	if( HPMHooks.count.HP_pc_nextjobexp_pre ) {
		unsigned int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.nextjobexp(sd);
	}
	if( HPMHooks.count.HP_pc_nextjobexp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, const struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_nextjobexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_nextjobexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
unsigned int HP_pc_thisjobexp(const struct map_session_data *sd) {
	int hIndex = 0;
	unsigned int retVal___ = 0;
	if( HPMHooks.count.HP_pc_thisjobexp_pre ) {
		unsigned int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.thisjobexp(sd);
	}
	if( HPMHooks.count.HP_pc_thisjobexp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, const struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_thisjobexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_thisjobexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_gets_status_point(int level) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.gets_status_point(level);
	}
	if( HPMHooks.count.HP_pc_gets_status_point_post ) {
		int (*postHookFunc) (int retVal___, int level);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_gets_status_point_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_gets_status_point_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, level);
		}
	}
	return retVal___;
}
int HP_pc_need_status_point(struct map_session_data *sd, int type, int val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.need_status_point(sd, type, val);
	}
	if( HPMHooks.count.HP_pc_need_status_point_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_need_status_point_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_need_status_point_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, val);
		}
	}
	return retVal___;
}
int HP_pc_maxparameterincrease(struct map_session_data *sd, int type) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.maxparameterincrease(sd, type);
	}
	if( HPMHooks.count.HP_pc_maxparameterincrease_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_maxparameterincrease_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_maxparameterincrease_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
bool HP_pc_statusup(struct map_session_data *sd, int type, int increase) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.statusup(sd, type, increase);
	}
	if( HPMHooks.count.HP_pc_statusup_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int type, int increase);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_statusup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, increase);
		}
	}
	return retVal___;
}
int HP_pc_statusup2(struct map_session_data *sd, int type, int val) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.statusup2(sd, type, val);
	}
	if( HPMHooks.count.HP_pc_statusup2_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_statusup2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_statusup2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, val);
		}
	}
	return retVal___;
}
int HP_pc_skillup(struct map_session_data *sd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.skillup(sd, skill_id);
	}
	if( HPMHooks.count.HP_pc_skillup_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_skillup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
int HP_pc_allskillup(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.allskillup(sd);
	}
	if( HPMHooks.count.HP_pc_allskillup_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_allskillup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_allskillup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_resetlvl(struct map_session_data *sd, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.resetlvl(sd, type);
	}
	if( HPMHooks.count.HP_pc_resetlvl_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetlvl_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_resetlvl_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
int HP_pc_resetstate(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.resetstate(sd);
	}
	if( HPMHooks.count.HP_pc_resetstate_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetstate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_resetstate_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_resetskill(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.resetskill(sd, flag);
	}
	if( HPMHooks.count.HP_pc_resetskill_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_resetskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, flag);
		}
	}
	return retVal___;
}
int HP_pc_resetfeel(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.resetfeel(sd);
	}
	if( HPMHooks.count.HP_pc_resetfeel_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resetfeel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_resetfeel_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_resethate(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.resethate(sd);
	}
	if( HPMHooks.count.HP_pc_resethate_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_resethate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_resethate_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_equipitem(struct map_session_data *sd, int n, int req_pos) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.equipitem(sd, n, req_pos);
	}
	if( HPMHooks.count.HP_pc_equipitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int req_pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_equipitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n, req_pos);
		}
	}
	return retVal___;
}
void HP_pc_equipitem_pos(struct map_session_data *sd, struct item_data *id, int n, int pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_equipitem_pos_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct item_data **id, int *n, int *pos);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_pos_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_equipitem_pos_pre[hIndex].func;
			preHookFunc(&sd, &id, &n, &pos);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.equipitem_pos(sd, id, n, pos);
	}
	if( HPMHooks.count.HP_pc_equipitem_pos_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct item_data *id, int n, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equipitem_pos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_equipitem_pos_post[hIndex].func;
			postHookFunc(sd, id, n, pos);
		}
	}
	return;
}
int HP_pc_unequipitem(struct map_session_data *sd, int n, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.unequipitem(sd, n, flag);
	}
	if( HPMHooks.count.HP_pc_unequipitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_unequipitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n, flag);
		}
	}
	return retVal___;
}
void HP_pc_unequipitem_pos(struct map_session_data *sd, int n, int pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_unequipitem_pos_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *n, int *pos);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_pos_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_unequipitem_pos_pre[hIndex].func;
			preHookFunc(&sd, &n, &pos);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.unequipitem_pos(sd, n, pos);
	}
	if( HPMHooks.count.HP_pc_unequipitem_pos_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int n, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_unequipitem_pos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_unequipitem_pos_post[hIndex].func;
			postHookFunc(sd, n, pos);
		}
	}
	return;
}
int HP_pc_checkitem(struct map_session_data *sd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkitem(sd);
	}
	if( HPMHooks.count.HP_pc_checkitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_useitem(struct map_session_data *sd, int n) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.useitem(sd, n);
	}
	if( HPMHooks.count.HP_pc_useitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_useitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_useitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n);
		}
	}
	return retVal___;
}
int HP_pc_skillatk_bonus(struct map_session_data *sd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.skillatk_bonus(sd, skill_id);
	}
	if( HPMHooks.count.HP_pc_skillatk_bonus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillatk_bonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_skillatk_bonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
int HP_pc_skillheal_bonus(struct map_session_data *sd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.skillheal_bonus(sd, skill_id);
	}
	if( HPMHooks.count.HP_pc_skillheal_bonus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal_bonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_skillheal_bonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
int HP_pc_skillheal2_bonus(struct map_session_data *sd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.skillheal2_bonus(sd, skill_id);
	}
	if( HPMHooks.count.HP_pc_skillheal2_bonus_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_skillheal2_bonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_skillheal2_bonus_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
void HP_pc_damage(struct map_session_data *sd, struct block_list *src, unsigned int hp, unsigned int sp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_damage_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct block_list **src, unsigned int *hp, unsigned int *sp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.damage(sd, src, hp, sp);
	}
	if( HPMHooks.count.HP_pc_damage_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct block_list *src, unsigned int hp, unsigned int sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_damage_post[hIndex].func;
			postHookFunc(sd, src, hp, sp);
		}
	}
	return;
}
int HP_pc_dead(struct map_session_data *sd, struct block_list *src) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.dead(sd, src);
	}
	if( HPMHooks.count.HP_pc_dead_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_dead_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_dead_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, src);
		}
	}
	return retVal___;
}
void HP_pc_revive(struct map_session_data *sd, unsigned int hp, unsigned int sp) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_revive_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *hp, unsigned int *sp);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.revive(sd, hp, sp);
	}
	if( HPMHooks.count.HP_pc_revive_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int hp, unsigned int sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_revive_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_revive_post[hIndex].func;
			postHookFunc(sd, hp, sp);
		}
	}
	return;
}
void HP_pc_heal(struct map_session_data *sd, unsigned int hp, unsigned int sp, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_heal_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *hp, unsigned int *sp, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.heal(sd, hp, sp, type);
	}
	if( HPMHooks.count.HP_pc_heal_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int hp, unsigned int sp, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_heal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_heal_post[hIndex].func;
			postHookFunc(sd, hp, sp, type);
		}
	}
	return;
}
int HP_pc_itemheal(struct map_session_data *sd, int itemid, int hp, int sp) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.itemheal(sd, itemid, hp, sp);
	}
	if( HPMHooks.count.HP_pc_itemheal_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int itemid, int hp, int sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemheal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_itemheal_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, itemid, hp, sp);
		}
	}
	return retVal___;
}
int HP_pc_percentheal(struct map_session_data *sd, int hp, int sp) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.percentheal(sd, hp, sp);
	}
	if( HPMHooks.count.HP_pc_percentheal_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int hp, int sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_percentheal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_percentheal_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, hp, sp);
		}
	}
	return retVal___;
}
int HP_pc_jobchange(struct map_session_data *sd, int job, int upper) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.jobchange(sd, job, upper);
	}
	if( HPMHooks.count.HP_pc_jobchange_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int job, int upper);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_jobchange_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, job, upper);
		}
	}
	return retVal___;
}
int HP_pc_setoption(struct map_session_data *sd, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setoption(sd, type);
	}
	if( HPMHooks.count.HP_pc_setoption_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setoption_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setoption_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
int HP_pc_setcart(struct map_session_data *sd, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setcart(sd, type);
	}
	if( HPMHooks.count.HP_pc_setcart_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setcart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setcart_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
void HP_pc_setfalcon(struct map_session_data *sd, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_setfalcon_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, bool *flag);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setfalcon_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_setfalcon_pre[hIndex].func;
			preHookFunc(&sd, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setfalcon(sd, flag);
	}
	if( HPMHooks.count.HP_pc_setfalcon_post ) {
		void (*postHookFunc) (struct map_session_data *sd, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setfalcon_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setfalcon_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_pc_setridingpeco(struct map_session_data *sd, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_setridingpeco_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, bool *flag);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingpeco_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_setridingpeco_pre[hIndex].func;
			preHookFunc(&sd, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setridingpeco(sd, flag);
	}
	if( HPMHooks.count.HP_pc_setridingpeco_post ) {
		void (*postHookFunc) (struct map_session_data *sd, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingpeco_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setridingpeco_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_pc_setmadogear(struct map_session_data *sd, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_setmadogear_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, bool *flag);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setmadogear_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_setmadogear_pre[hIndex].func;
			preHookFunc(&sd, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setmadogear(sd, flag);
	}
	if( HPMHooks.count.HP_pc_setmadogear_post ) {
		void (*postHookFunc) (struct map_session_data *sd, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setmadogear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setmadogear_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
void HP_pc_setridingdragon(struct map_session_data *sd, unsigned int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_setridingdragon_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *type);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingdragon_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_setridingdragon_pre[hIndex].func;
			preHookFunc(&sd, &type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setridingdragon(sd, type);
	}
	if( HPMHooks.count.HP_pc_setridingdragon_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingdragon_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setridingdragon_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
void HP_pc_setridingwug(struct map_session_data *sd, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_setridingwug_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, bool *flag);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingwug_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_setridingwug_pre[hIndex].func;
			preHookFunc(&sd, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setridingwug(sd, flag);
	}
	if( HPMHooks.count.HP_pc_setridingwug_post ) {
		void (*postHookFunc) (struct map_session_data *sd, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setridingwug_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setridingwug_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
int HP_pc_changelook(struct map_session_data *sd, int type, int val) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.changelook(sd, type, val);
	}
	if( HPMHooks.count.HP_pc_changelook_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_changelook_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_changelook_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, val);
		}
	}
	return retVal___;
}
int HP_pc_equiplookall(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.equiplookall(sd);
	}
	if( HPMHooks.count.HP_pc_equiplookall_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_equiplookall_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_equiplookall_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_readparam(const struct map_session_data *sd, int type) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_readparam_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.readparam(sd, type);
	}
	if( HPMHooks.count.HP_pc_readparam_post ) {
		int (*postHookFunc) (int retVal___, const struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readparam_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_readparam_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
int HP_pc_setparam(struct map_session_data *sd, int type, int val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setparam(sd, type, val);
	}
	if( HPMHooks.count.HP_pc_setparam_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setparam_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setparam_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, val);
		}
	}
	return retVal___;
}
int HP_pc_readreg(struct map_session_data *sd, int64 reg) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.readreg(sd, reg);
	}
	if( HPMHooks.count.HP_pc_readreg_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 reg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readreg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_readreg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, reg);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setreg(sd, reg, val);
	}
	if( HPMHooks.count.HP_pc_setreg_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int64 reg, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setreg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setreg_post[hIndex].func;
			postHookFunc(sd, reg, val);
		}
	}
	return;
}
char* HP_pc_readregstr(struct map_session_data *sd, int64 reg) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.readregstr(sd, reg);
	}
	if( HPMHooks.count.HP_pc_readregstr_post ) {
		char* (*postHookFunc) (char* retVal___, struct map_session_data *sd, int64 reg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregstr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_readregstr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, reg);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setregstr(sd, reg, str);
	}
	if( HPMHooks.count.HP_pc_setregstr_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int64 reg, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregstr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setregstr_post[hIndex].func;
			postHookFunc(sd, reg, str);
		}
	}
	return;
}
int HP_pc_readregistry(struct map_session_data *sd, int64 reg) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.readregistry(sd, reg);
	}
	if( HPMHooks.count.HP_pc_readregistry_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 reg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_readregistry_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, reg);
		}
	}
	return retVal___;
}
int HP_pc_setregistry(struct map_session_data *sd, int64 reg, int val) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setregistry(sd, reg, val);
	}
	if( HPMHooks.count.HP_pc_setregistry_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 reg, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setregistry_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, reg, val);
		}
	}
	return retVal___;
}
char* HP_pc_readregistry_str(struct map_session_data *sd, int64 reg) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.readregistry_str(sd, reg);
	}
	if( HPMHooks.count.HP_pc_readregistry_str_post ) {
		char* (*postHookFunc) (char* retVal___, struct map_session_data *sd, int64 reg);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readregistry_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_readregistry_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, reg);
		}
	}
	return retVal___;
}
int HP_pc_setregistry_str(struct map_session_data *sd, int64 reg, const char *val) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setregistry_str(sd, reg, val);
	}
	if( HPMHooks.count.HP_pc_setregistry_str_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int64 reg, const char *val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setregistry_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setregistry_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, reg, val);
		}
	}
	return retVal___;
}
int HP_pc_addeventtimer(struct map_session_data *sd, int tick, const char *name) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.addeventtimer(sd, tick, name);
	}
	if( HPMHooks.count.HP_pc_addeventtimer_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int tick, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_addeventtimer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, tick, name);
		}
	}
	return retVal___;
}
int HP_pc_deleventtimer(struct map_session_data *sd, const char *name) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.deleventtimer(sd, name);
	}
	if( HPMHooks.count.HP_pc_deleventtimer_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_deleventtimer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_deleventtimer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name);
		}
	}
	return retVal___;
}
int HP_pc_cleareventtimer(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.cleareventtimer(sd);
	}
	if( HPMHooks.count.HP_pc_cleareventtimer_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_cleareventtimer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_cleareventtimer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_addeventtimercount(struct map_session_data *sd, const char *name, int tick) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.addeventtimercount(sd, name, tick);
	}
	if( HPMHooks.count.HP_pc_addeventtimercount_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addeventtimercount_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_addeventtimercount_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name, tick);
		}
	}
	return retVal___;
}
int HP_pc_calc_pvprank(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.calc_pvprank(sd);
	}
	if( HPMHooks.count.HP_pc_calc_pvprank_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_pvprank_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_calc_pvprank_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_calc_pvprank_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.calc_pvprank_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_calc_pvprank_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_pvprank_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_calc_pvprank_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_ismarried(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.ismarried(sd);
	}
	if( HPMHooks.count.HP_pc_ismarried_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_ismarried_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_ismarried_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_marriage(struct map_session_data *sd, struct map_session_data *dstsd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.marriage(sd, dstsd);
	}
	if( HPMHooks.count.HP_pc_marriage_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *dstsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_marriage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_marriage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, dstsd);
		}
	}
	return retVal___;
}
int HP_pc_divorce(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.divorce(sd);
	}
	if( HPMHooks.count.HP_pc_divorce_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_divorce_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_divorce_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
struct map_session_data* HP_pc_get_partner(struct map_session_data *sd) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_pc_get_partner_pre ) {
		struct map_session_data* (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.get_partner(sd);
	}
	if( HPMHooks.count.HP_pc_get_partner_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_partner_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_get_partner_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
struct map_session_data* HP_pc_get_father(struct map_session_data *sd) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_pc_get_father_pre ) {
		struct map_session_data* (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.get_father(sd);
	}
	if( HPMHooks.count.HP_pc_get_father_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_father_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_get_father_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
struct map_session_data* HP_pc_get_mother(struct map_session_data *sd) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_pc_get_mother_pre ) {
		struct map_session_data* (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.get_mother(sd);
	}
	if( HPMHooks.count.HP_pc_get_mother_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_mother_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_get_mother_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
struct map_session_data* HP_pc_get_child(struct map_session_data *sd) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_pc_get_child_pre ) {
		struct map_session_data* (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.get_child(sd);
	}
	if( HPMHooks.count.HP_pc_get_child_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_get_child_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_get_child_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_pc_bleeding(struct map_session_data *sd, unsigned int diff_tick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_bleeding_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *diff_tick);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.bleeding(sd, diff_tick);
	}
	if( HPMHooks.count.HP_pc_bleeding_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int diff_tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bleeding_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bleeding_post[hIndex].func;
			postHookFunc(sd, diff_tick);
		}
	}
	return;
}
void HP_pc_regen(struct map_session_data *sd, unsigned int diff_tick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_regen_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *diff_tick);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.regen(sd, diff_tick);
	}
	if( HPMHooks.count.HP_pc_regen_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int diff_tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_regen_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_regen_post[hIndex].func;
			postHookFunc(sd, diff_tick);
		}
	}
	return;
}
void HP_pc_setstand(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_setstand_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setstand(sd);
	}
	if( HPMHooks.count.HP_pc_setstand_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstand_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setstand_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_pc_candrop(struct map_session_data *sd, struct item *item) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.candrop(sd, item);
	}
	if( HPMHooks.count.HP_pc_candrop_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_candrop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_candrop_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item);
		}
	}
	return retVal___;
}
int HP_pc_jobid2mapid(unsigned short b_class) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.jobid2mapid(b_class);
	}
	if( HPMHooks.count.HP_pc_jobid2mapid_post ) {
		int (*postHookFunc) (int retVal___, unsigned short b_class);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobid2mapid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_jobid2mapid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, b_class);
		}
	}
	return retVal___;
}
int HP_pc_mapid2jobid(unsigned short class_, int sex) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.mapid2jobid(class_, sex);
	}
	if( HPMHooks.count.HP_pc_mapid2jobid_post ) {
		int (*postHookFunc) (int retVal___, unsigned short class_, int sex);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_mapid2jobid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_mapid2jobid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_, sex);
		}
	}
	return retVal___;
}
const char* HP_pc_job_name(int class_) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_pc_job_name_pre ) {
		const char* (*preHookFunc) (int *class_);
		*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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.job_name(class_);
	}
	if( HPMHooks.count.HP_pc_job_name_post ) {
		const char* (*postHookFunc) (const char* retVal___, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_job_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_job_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
void HP_pc_setinvincibletimer(struct map_session_data *sd, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_setinvincibletimer_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.setinvincibletimer(sd, val);
	}
	if( HPMHooks.count.HP_pc_setinvincibletimer_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setinvincibletimer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setinvincibletimer_post[hIndex].func;
			postHookFunc(sd, val);
		}
	}
	return;
}
void HP_pc_delinvincibletimer(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_delinvincibletimer_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.delinvincibletimer(sd);
	}
	if( HPMHooks.count.HP_pc_delinvincibletimer_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delinvincibletimer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_delinvincibletimer_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_pc_addspiritball(struct map_session_data *sd, int interval, int max) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.addspiritball(sd, interval, max);
	}
	if( HPMHooks.count.HP_pc_addspiritball_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int interval, int max);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addspiritball_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_addspiritball_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, interval, max);
		}
	}
	return retVal___;
}
int HP_pc_delspiritball(struct map_session_data *sd, int count, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.delspiritball(sd, count, type);
	}
	if( HPMHooks.count.HP_pc_delspiritball_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int count, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_delspiritball_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_delspiritball_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, count, type);
		}
	}
	return retVal___;
}
int HP_pc_getmaxspiritball(struct map_session_data *sd, int min) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_getmaxspiritball_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, int *min);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getmaxspiritball_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_getmaxspiritball_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &min);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.getmaxspiritball(sd, min);
	}
	if( HPMHooks.count.HP_pc_getmaxspiritball_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int min);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getmaxspiritball_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_getmaxspiritball_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, min);
		}
	}
	return retVal___;
}
void HP_pc_addfame(struct map_session_data *sd, int count) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_addfame_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *count);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.addfame(sd, count);
	}
	if( HPMHooks.count.HP_pc_addfame_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_addfame_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_addfame_post[hIndex].func;
			postHookFunc(sd, count);
		}
	}
	return;
}
unsigned char HP_pc_famerank(int char_id, int job) {
	int hIndex = 0;
	unsigned char retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.famerank(char_id, job);
	}
	if( HPMHooks.count.HP_pc_famerank_post ) {
		unsigned char (*postHookFunc) (unsigned char retVal___, int char_id, int job);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_famerank_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_famerank_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, char_id, job);
		}
	}
	return retVal___;
}
int HP_pc_set_hate_mob(struct map_session_data *sd, int pos, struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.set_hate_mob(sd, pos, bl);
	}
	if( HPMHooks.count.HP_pc_set_hate_mob_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int pos, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_set_hate_mob_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_set_hate_mob_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, pos, bl);
		}
	}
	return retVal___;
}
int HP_pc_readdb(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.readdb();
	}
	if( HPMHooks.count.HP_pc_readdb_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_readdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_pc_map_day_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.map_day_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_map_day_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_map_day_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_map_day_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_map_night_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.map_night_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_map_night_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_map_night_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_map_night_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_pc_inventory_rentals(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_inventory_rentals_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.inventory_rentals(sd);
	}
	if( HPMHooks.count.HP_pc_inventory_rentals_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rentals_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_inventory_rentals_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_pc_inventory_rental_clear(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.inventory_rental_clear(sd);
	}
	if( HPMHooks.count.HP_pc_inventory_rental_clear_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_inventory_rental_clear_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_pc_inventory_rental_add(struct map_session_data *sd, int seconds) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_inventory_rental_add_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *seconds);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.inventory_rental_add(sd, seconds);
	}
	if( HPMHooks.count.HP_pc_inventory_rental_add_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int seconds);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_inventory_rental_add_post[hIndex].func;
			postHookFunc(sd, seconds);
		}
	}
	return;
}
int HP_pc_disguise(struct map_session_data *sd, int class_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.disguise(sd, class_);
	}
	if( HPMHooks.count.HP_pc_disguise_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_disguise_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_disguise_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, class_);
		}
	}
	return retVal___;
}
bool HP_pc_isautolooting(struct map_session_data *sd, int nameid) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.isautolooting(sd, nameid);
	}
	if( HPMHooks.count.HP_pc_isautolooting_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isautolooting_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_isautolooting_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid);
		}
	}
	return retVal___;
}
void HP_pc_overheat(struct map_session_data *sd, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_overheat_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *val);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.overheat(sd, val);
	}
	if( HPMHooks.count.HP_pc_overheat_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_overheat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_overheat_post[hIndex].func;
			postHookFunc(sd, val);
		}
	}
	return;
}
int HP_pc_banding(struct map_session_data *sd, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.banding(sd, skill_lv);
	}
	if( HPMHooks.count.HP_pc_banding_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_banding_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_banding_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_lv);
		}
	}
	return retVal___;
}
void HP_pc_itemcd_do(struct map_session_data *sd, bool load) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_itemcd_do_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, bool *load);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.itemcd_do(sd, load);
	}
	if( HPMHooks.count.HP_pc_itemcd_do_post ) {
		void (*postHookFunc) (struct map_session_data *sd, bool load);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_itemcd_do_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_itemcd_do_post[hIndex].func;
			postHookFunc(sd, load);
		}
	}
	return;
}
int HP_pc_load_combo(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.load_combo(sd);
	}
	if( HPMHooks.count.HP_pc_load_combo_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_load_combo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_load_combo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_pc_add_charm(struct map_session_data *sd, int interval, int max, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_add_charm_pre ) {
		void (*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;
			preHookFunc(&sd, &interval, &max, &type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.add_charm(sd, interval, max, type);
	}
	if( HPMHooks.count.HP_pc_add_charm_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int interval, int max, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_add_charm_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_add_charm_post[hIndex].func;
			postHookFunc(sd, interval, max, type);
		}
	}
	return;
}
void HP_pc_del_charm(struct map_session_data *sd, int count, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_del_charm_pre ) {
		void (*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;
			preHookFunc(&sd, &count, &type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.del_charm(sd, count, type);
	}
	if( HPMHooks.count.HP_pc_del_charm_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int count, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_del_charm_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_del_charm_post[hIndex].func;
			postHookFunc(sd, count, type);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.baselevelchanged(sd);
	}
	if( HPMHooks.count.HP_pc_baselevelchanged_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_baselevelchanged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_baselevelchanged_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_pc_level_penalty_mod(int diff, unsigned char race, uint32 mode, int type) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_level_penalty_mod_pre ) {
		int (*preHookFunc) (int *diff, unsigned char *race, uint32 *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.level_penalty_mod(diff, race, mode, type);
	}
	if( HPMHooks.count.HP_pc_level_penalty_mod_post ) {
		int (*postHookFunc) (int retVal___, int diff, unsigned char race, uint32 mode, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_level_penalty_mod_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_level_penalty_mod_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, diff, race, mode, type);
		}
	}
	return retVal___;
}
int HP_pc_calc_skillpoint(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.calc_skillpoint(sd);
	}
	if( HPMHooks.count.HP_pc_calc_skillpoint_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calc_skillpoint_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_calc_skillpoint_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_invincible_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.invincible_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_invincible_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_invincible_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_invincible_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_spiritball_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.spiritball_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_spiritball_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_spiritball_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_spiritball_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_check_banding(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.pc.check_banding(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_pc_check_banding_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_banding_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_pc_check_banding_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_pc_inventory_rental_end(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.inventory_rental_end(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_inventory_rental_end_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_inventory_rental_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_inventory_rental_end_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_pc_check_skilltree(struct map_session_data *sd, int skill_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_check_skilltree_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *skill_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.check_skilltree(sd, skill_id);
	}
	if( HPMHooks.count.HP_pc_check_skilltree_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_skilltree_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_check_skilltree_post[hIndex].func;
			postHookFunc(sd, skill_id);
		}
	}
	return;
}
int HP_pc_bonus_autospell(struct s_autospell *spell, int max, short id, short lv, short rate, short flag, short card_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus_autospell(spell, max, id, lv, rate, flag, card_id);
	}
	if( HPMHooks.count.HP_pc_bonus_autospell_post ) {
		int (*postHookFunc) (int retVal___, struct s_autospell *spell, int max, short id, short lv, short rate, short flag, short card_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus_autospell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, spell, max, id, lv, rate, flag, card_id);
		}
	}
	return retVal___;
}
int HP_pc_bonus_autospell_onskill(struct s_autospell *spell, int max, short src_skill, short id, short lv, short rate, short card_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus_autospell_onskill(spell, max, src_skill, id, lv, rate, card_id);
	}
	if( HPMHooks.count.HP_pc_bonus_autospell_onskill_post ) {
		int (*postHookFunc) (int retVal___, struct s_autospell *spell, int max, short src_skill, short id, short lv, short rate, short card_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_autospell_onskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus_autospell_onskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, spell, max, src_skill, id, lv, rate, card_id);
		}
	}
	return retVal___;
}
int HP_pc_bonus_addeff(struct s_addeffect *effect, int max, enum sc_type id, int16 rate, int16 arrow_rate, uint8 flag, uint16 duration) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_bonus_addeff_pre ) {
		int (*preHookFunc) (struct s_addeffect **effect, int *max, enum sc_type *id, int16 *rate, int16 *arrow_rate, uint8 *flag, uint16 *duration);
		*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, &duration);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus_addeff(effect, max, id, rate, arrow_rate, flag, duration);
	}
	if( HPMHooks.count.HP_pc_bonus_addeff_post ) {
		int (*postHookFunc) (int retVal___, struct s_addeffect *effect, int max, enum sc_type id, int16 rate, int16 arrow_rate, uint8 flag, uint16 duration);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus_addeff_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, effect, max, id, rate, arrow_rate, flag, duration);
		}
	}
	return retVal___;
}
int HP_pc_bonus_addeff_onskill(struct s_addeffectonskill *effect, int max, enum sc_type id, short rate, short skill_id, unsigned char target) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus_addeff_onskill(effect, max, id, rate, skill_id, target);
	}
	if( HPMHooks.count.HP_pc_bonus_addeff_onskill_post ) {
		int (*postHookFunc) (int retVal___, struct s_addeffectonskill *effect, int max, enum sc_type id, short rate, short skill_id, unsigned char target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_addeff_onskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus_addeff_onskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, effect, max, id, rate, skill_id, target);
		}
	}
	return retVal___;
}
int HP_pc_bonus_item_drop(struct s_add_drop *drop, const short max, short id, short group, int race, int rate) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.bonus_item_drop(drop, max, id, group, race, rate);
	}
	if( HPMHooks.count.HP_pc_bonus_item_drop_post ) {
		int (*postHookFunc) (int retVal___, struct s_add_drop *drop, const short max, short id, short group, int race, int rate);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bonus_item_drop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bonus_item_drop_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, drop, max, id, group, race, rate);
		}
	}
	return retVal___;
}
void HP_pc_calcexp(struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_calcexp_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int **base_exp, unsigned int **job_exp, struct block_list **src);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.calcexp(sd, base_exp, job_exp, src);
	}
	if( HPMHooks.count.HP_pc_calcexp_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int *base_exp, unsigned int *job_exp, struct block_list *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_calcexp_post[hIndex].func;
			postHookFunc(sd, base_exp, job_exp, src);
		}
	}
	return;
}
int HP_pc_respawn_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.respawn_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_respawn_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_respawn_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_respawn_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_jobchange_killclone(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.pc.jobchange_killclone(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_pc_jobchange_killclone_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_jobchange_killclone_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_pc_jobchange_killclone_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_pc_getstat(struct map_session_data *sd, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.getstat(sd, type);
	}
	if( HPMHooks.count.HP_pc_getstat_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_getstat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_getstat_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
int HP_pc_setstat(struct map_session_data *sd, int type, int val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.setstat(sd, type, val);
	}
	if( HPMHooks.count.HP_pc_setstat_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_setstat_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_setstat_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type, val);
		}
	}
	return retVal___;
}
int HP_pc_eventtimer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.eventtimer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_eventtimer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_eventtimer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_eventtimer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_daynight_timer_sub(struct map_session_data *sd, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.pc.daynight_timer_sub(sd, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_pc_daynight_timer_sub_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_daynight_timer_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_pc_daynight_timer_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_pc_charm_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.charm_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_charm_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_charm_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_charm_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
bool HP_pc_readdb_levelpenalty(char *fields[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.readdb_levelpenalty(fields, columns, current);
	}
	if( HPMHooks.count.HP_pc_readdb_levelpenalty_post ) {
		bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_readdb_levelpenalty_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_readdb_levelpenalty_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fields, columns, current);
		}
	}
	return retVal___;
}
int HP_pc_autosave(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.autosave(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_autosave_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autosave_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_autosave_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_follow_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.follow_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_follow_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_follow_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_follow_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_pc_read_skill_tree(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_read_skill_tree_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.read_skill_tree();
	}
	if( HPMHooks.count.HP_pc_read_skill_tree_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_read_skill_tree_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_read_skill_tree_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_pc_clear_skill_tree(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_clear_skill_tree_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_clear_skill_tree_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_clear_skill_tree_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.clear_skill_tree();
	}
	if( HPMHooks.count.HP_pc_clear_skill_tree_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_clear_skill_tree_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_clear_skill_tree_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_pc_isUseitem(struct map_session_data *sd, int n) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.isUseitem(sd, n);
	}
	if( HPMHooks.count.HP_pc_isUseitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_isUseitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_isUseitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n);
		}
	}
	return retVal___;
}
int HP_pc_show_steal(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.pc.show_steal(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_pc_show_steal_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_show_steal_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_pc_show_steal_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_pc_checkcombo(struct map_session_data *sd, struct item_data *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.checkcombo(sd, data);
	}
	if( HPMHooks.count.HP_pc_checkcombo_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_checkcombo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_checkcombo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, data);
		}
	}
	return retVal___;
}
int HP_pc_calcweapontype(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.calcweapontype(sd);
	}
	if( HPMHooks.count.HP_pc_calcweapontype_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_calcweapontype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_calcweapontype_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_pc_removecombo(struct map_session_data *sd, struct item_data *data) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.removecombo(sd, data);
	}
	if( HPMHooks.count.HP_pc_removecombo_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_removecombo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_removecombo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, data);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.bank_deposit(sd, money);
	}
	if( HPMHooks.count.HP_pc_bank_deposit_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int money);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bank_deposit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bank_deposit_post[hIndex].func;
			postHookFunc(sd, money);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.bank_withdraw(sd, money);
	}
	if( HPMHooks.count.HP_pc_bank_withdraw_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int money);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bank_withdraw_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bank_withdraw_post[hIndex].func;
			postHookFunc(sd, money);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.rental_expire(sd, i);
	}
	if( HPMHooks.count.HP_pc_rental_expire_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int i);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_rental_expire_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_rental_expire_post[hIndex].func;
			postHookFunc(sd, i);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.scdata_received(sd);
	}
	if( HPMHooks.count.HP_pc_scdata_received_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_scdata_received_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_scdata_received_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.bound_clear(sd, type);
	}
	if( HPMHooks.count.HP_pc_bound_clear_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum e_item_bound_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_bound_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_bound_clear_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
int HP_pc_expiration_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.expiration_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_expiration_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_expiration_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_expiration_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pc_global_expiration_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.global_expiration_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pc_global_expiration_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_global_expiration_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_global_expiration_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.expire_check(sd);
	}
	if( HPMHooks.count.HP_pc_expire_check_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_expire_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_expire_check_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
bool HP_pc_db_checkid(unsigned int class_) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_pc_db_checkid_pre ) {
		bool (*preHookFunc) (unsigned int *class_);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_db_checkid_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_db_checkid_pre[hIndex].func;
			retVal___ = preHookFunc(&class_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.db_checkid(class_);
	}
	if( HPMHooks.count.HP_pc_db_checkid_post ) {
		bool (*postHookFunc) (bool retVal___, unsigned int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_db_checkid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_db_checkid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, class_);
		}
	}
	return retVal___;
}
void HP_pc_validate_levels(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_validate_levels_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_validate_levels_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_validate_levels_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.validate_levels();
	}
	if( HPMHooks.count.HP_pc_validate_levels_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_validate_levels_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_validate_levels_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.autotrade_load();
	}
	if( HPMHooks.count.HP_pc_autotrade_load_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_load_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_autotrade_load_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_pc_autotrade_update(struct map_session_data *sd, enum e_pc_autotrade_update_action action) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.autotrade_update(sd, action);
	}
	if( HPMHooks.count.HP_pc_autotrade_update_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum e_pc_autotrade_update_action action);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_update_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_autotrade_update_post[hIndex].func;
			postHookFunc(sd, action);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.autotrade_start(sd);
	}
	if( HPMHooks.count.HP_pc_autotrade_start_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_autotrade_start_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.autotrade_prepare(sd);
	}
	if( HPMHooks.count.HP_pc_autotrade_prepare_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_prepare_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_autotrade_prepare_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.autotrade_populate(sd);
	}
	if( HPMHooks.count.HP_pc_autotrade_populate_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_populate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_autotrade_populate_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_pc_autotrade_final(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_autotrade_final_pre ) {
		int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_final_pre; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			preHookFunc = HPMHooks.list.HP_pc_autotrade_final_pre[hIndex].func;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.pc.autotrade_final(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_pc_autotrade_final_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_autotrade_final_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_pc_autotrade_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_pc_check_job_name(const char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_check_job_name_pre ) {
		int (*preHookFunc) (const char **name);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_job_name_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_check_job_name_pre[hIndex].func;
			retVal___ = preHookFunc(&name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.check_job_name(name);
	}
	if( HPMHooks.count.HP_pc_check_job_name_post ) {
		int (*postHookFunc) (int retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_job_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_check_job_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
void HP_pc_update_idle_time(struct map_session_data *sd, enum e_battle_config_idletime type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_update_idle_time_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum e_battle_config_idletime *type);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_update_idle_time_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_update_idle_time_pre[hIndex].func;
			preHookFunc(&sd, &type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.update_idle_time(sd, type);
	}
	if( HPMHooks.count.HP_pc_update_idle_time_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum e_battle_config_idletime type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_update_idle_time_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_update_idle_time_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
int HP_pc_have_magnifier(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pc_have_magnifier_pre ) {
		int (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_have_magnifier_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_have_magnifier_pre[hIndex].func;
			retVal___ = preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.have_magnifier(sd);
	}
	if( HPMHooks.count.HP_pc_have_magnifier_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_have_magnifier_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_have_magnifier_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
bool HP_pc_process_chat_message(struct map_session_data *sd, const char *message) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_pc_process_chat_message_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd, const char **message);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_process_chat_message_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_process_chat_message_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &message);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pc.process_chat_message(sd, message);
	}
	if( HPMHooks.count.HP_pc_process_chat_message_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_process_chat_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_process_chat_message_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, message);
		}
	}
	return retVal___;
}
void HP_pc_check_supernovice_call(struct map_session_data *sd, const char *message) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pc_check_supernovice_call_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **message);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_supernovice_call_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_pc_check_supernovice_call_pre[hIndex].func;
			preHookFunc(&sd, &message);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pc.check_supernovice_call(sd, message);
	}
	if( HPMHooks.count.HP_pc_check_supernovice_call_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *message);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pc_check_supernovice_call_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pc_check_supernovice_call_post[hIndex].func;
			postHookFunc(sd, message);
		}
	}
	return;
}
/* pcre_interface */
pcre* HP_libpcre_compile(const char *pattern, int options, const char **errptr, int *erroffset, const unsigned char *tableptr) {
	int hIndex = 0;
	pcre* retVal___ = NULL;
	if( HPMHooks.count.HP_libpcre_compile_pre ) {
		pcre* (*preHookFunc) (const char **pattern, int *options, const char ***errptr, int **erroffset, const unsigned char **tableptr);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_compile_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libpcre_compile_pre[hIndex].func;
			retVal___ = preHookFunc(&pattern, &options, &errptr, &erroffset, &tableptr);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libpcre.compile(pattern, options, errptr, erroffset, tableptr);
	}
	if( HPMHooks.count.HP_libpcre_compile_post ) {
		pcre* (*postHookFunc) (pcre* retVal___, const char *pattern, int options, const char **errptr, int *erroffset, const unsigned char *tableptr);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_compile_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libpcre_compile_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pattern, options, errptr, erroffset, tableptr);
		}
	}
	return retVal___;
}
pcre_extra* HP_libpcre_study(const pcre *code, int options, const char **errptr) {
	int hIndex = 0;
	pcre_extra* retVal___ = NULL;
	if( HPMHooks.count.HP_libpcre_study_pre ) {
		pcre_extra* (*preHookFunc) (const pcre **code, int *options, const char ***errptr);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_study_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libpcre_study_pre[hIndex].func;
			retVal___ = preHookFunc(&code, &options, &errptr);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libpcre.study(code, options, errptr);
	}
	if( HPMHooks.count.HP_libpcre_study_post ) {
		pcre_extra* (*postHookFunc) (pcre_extra* retVal___, const pcre *code, int options, const char **errptr);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_study_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libpcre_study_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, code, options, errptr);
		}
	}
	return retVal___;
}
int HP_libpcre_exec(const pcre *code, const pcre_extra *extra, PCRE_SPTR subject, int length, int startoffset, int options, int *ovector, int ovecsize) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libpcre_exec_pre ) {
		int (*preHookFunc) (const pcre **code, const pcre_extra **extra, PCRE_SPTR *subject, int *length, int *startoffset, int *options, int **ovector, int *ovecsize);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_exec_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libpcre_exec_pre[hIndex].func;
			retVal___ = preHookFunc(&code, &extra, &subject, &length, &startoffset, &options, &ovector, &ovecsize);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libpcre.exec(code, extra, subject, length, startoffset, options, ovector, ovecsize);
	}
	if( HPMHooks.count.HP_libpcre_exec_post ) {
		int (*postHookFunc) (int retVal___, const pcre *code, const pcre_extra *extra, PCRE_SPTR subject, int length, int startoffset, int options, int *ovector, int ovecsize);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_exec_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libpcre_exec_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, code, extra, subject, length, startoffset, options, ovector, ovecsize);
		}
	}
	return retVal___;
}
void HP_libpcre_free(void *ptr) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libpcre_free_pre ) {
		void (*preHookFunc) (void **ptr);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_free_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libpcre_free_pre[hIndex].func;
			preHookFunc(&ptr);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libpcre.free(ptr);
	}
	if( HPMHooks.count.HP_libpcre_free_post ) {
		void (*postHookFunc) (void *ptr);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_free_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libpcre_free_post[hIndex].func;
			postHookFunc(ptr);
		}
	}
	return;
}
int HP_libpcre_copy_substring(const char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, int buffersize) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libpcre_copy_substring_pre ) {
		int (*preHookFunc) (const char **subject, int **ovector, int *stringcount, int *stringnumber, char **buffer, int *buffersize);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_copy_substring_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libpcre_copy_substring_pre[hIndex].func;
			retVal___ = preHookFunc(&subject, &ovector, &stringcount, &stringnumber, &buffer, &buffersize);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libpcre.copy_substring(subject, ovector, stringcount, stringnumber, buffer, buffersize);
	}
	if( HPMHooks.count.HP_libpcre_copy_substring_post ) {
		int (*postHookFunc) (int retVal___, const char *subject, int *ovector, int stringcount, int stringnumber, char *buffer, int buffersize);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_copy_substring_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libpcre_copy_substring_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, subject, ovector, stringcount, stringnumber, buffer, buffersize);
		}
	}
	return retVal___;
}
void HP_libpcre_free_substring(const char *stringptr) {
	int hIndex = 0;
	if( HPMHooks.count.HP_libpcre_free_substring_pre ) {
		void (*preHookFunc) (const char **stringptr);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_free_substring_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libpcre_free_substring_pre[hIndex].func;
			preHookFunc(&stringptr);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.libpcre.free_substring(stringptr);
	}
	if( HPMHooks.count.HP_libpcre_free_substring_post ) {
		void (*postHookFunc) (const char *stringptr);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_free_substring_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libpcre_free_substring_post[hIndex].func;
			postHookFunc(stringptr);
		}
	}
	return;
}
int HP_libpcre_copy_named_substring(const pcre *code, const char *subject, int *ovector, int stringcount, const char *stringname, char *buffer, int buffersize) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libpcre_copy_named_substring_pre ) {
		int (*preHookFunc) (const pcre **code, const char **subject, int **ovector, int *stringcount, const char **stringname, char **buffer, int *buffersize);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_copy_named_substring_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libpcre_copy_named_substring_pre[hIndex].func;
			retVal___ = preHookFunc(&code, &subject, &ovector, &stringcount, &stringname, &buffer, &buffersize);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libpcre.copy_named_substring(code, subject, ovector, stringcount, stringname, buffer, buffersize);
	}
	if( HPMHooks.count.HP_libpcre_copy_named_substring_post ) {
		int (*postHookFunc) (int retVal___, const pcre *code, const char *subject, int *ovector, int stringcount, const char *stringname, char *buffer, int buffersize);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_copy_named_substring_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libpcre_copy_named_substring_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, code, subject, ovector, stringcount, stringname, buffer, buffersize);
		}
	}
	return retVal___;
}
int HP_libpcre_get_substring(const char *subject, int *ovector, int stringcount, int stringnumber, const char **stringptr) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_libpcre_get_substring_pre ) {
		int (*preHookFunc) (const char **subject, int **ovector, int *stringcount, int *stringnumber, const char ***stringptr);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_get_substring_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_libpcre_get_substring_pre[hIndex].func;
			retVal___ = preHookFunc(&subject, &ovector, &stringcount, &stringnumber, &stringptr);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.libpcre.get_substring(subject, ovector, stringcount, stringnumber, stringptr);
	}
	if( HPMHooks.count.HP_libpcre_get_substring_post ) {
		int (*postHookFunc) (int retVal___, const char *subject, int *ovector, int stringcount, int stringnumber, const char **stringptr);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_libpcre_get_substring_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_libpcre_get_substring_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, subject, ovector, stringcount, stringnumber, stringptr);
		}
	}
	return retVal___;
}
/* pet_interface */
int HP_pet_init(bool minimal) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.init(minimal);
	}
	if( HPMHooks.count.HP_pet_init_post ) {
		int (*postHookFunc) (int retVal___, bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, minimal);
		}
	}
	return retVal___;
}
int HP_pet_final(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.final();
	}
	if( HPMHooks.count.HP_pet_final_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_pet_hungry_val(struct pet_data *pd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.hungry_val(pd);
	}
	if( HPMHooks.count.HP_pet_hungry_val_post ) {
		int (*postHookFunc) (int retVal___, struct pet_data *pd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_val_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_hungry_val_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pd);
		}
	}
	return retVal___;
}
void HP_pet_set_intimate(struct pet_data *pd, int value) {
	int hIndex = 0;
	if( HPMHooks.count.HP_pet_set_intimate_pre ) {
		void (*preHookFunc) (struct pet_data **pd, int *value);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.pet.set_intimate(pd, value);
	}
	if( HPMHooks.count.HP_pet_set_intimate_post ) {
		void (*postHookFunc) (struct pet_data *pd, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_set_intimate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_set_intimate_post[hIndex].func;
			postHookFunc(pd, value);
		}
	}
	return;
}
int HP_pet_create_egg(struct map_session_data *sd, int item_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.create_egg(sd, item_id);
	}
	if( HPMHooks.count.HP_pet_create_egg_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int item_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_create_egg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_create_egg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_id);
		}
	}
	return retVal___;
}
int HP_pet_unlocktarget(struct pet_data *pd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.unlocktarget(pd);
	}
	if( HPMHooks.count.HP_pet_unlocktarget_post ) {
		int (*postHookFunc) (int retVal___, struct pet_data *pd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unlocktarget_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_unlocktarget_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pd);
		}
	}
	return retVal___;
}
int HP_pet_attackskill(struct pet_data *pd, int target_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.attackskill(pd, target_id);
	}
	if( HPMHooks.count.HP_pet_attackskill_post ) {
		int (*postHookFunc) (int retVal___, struct pet_data *pd, int target_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_attackskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_attackskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pd, target_id);
		}
	}
	return retVal___;
}
int HP_pet_target_check(struct map_session_data *sd, struct block_list *bl, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.target_check(sd, bl, type);
	}
	if( HPMHooks.count.HP_pet_target_check_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_target_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_target_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, bl, type);
		}
	}
	return retVal___;
}
int HP_pet_sc_check(struct map_session_data *sd, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.sc_check(sd, type);
	}
	if( HPMHooks.count.HP_pet_sc_check_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_sc_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_sc_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
int HP_pet_hungry(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.hungry(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pet_hungry_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_hungry_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pet_search_petDB_index(int key, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.search_petDB_index(key, type);
	}
	if( HPMHooks.count.HP_pet_search_petDB_index_post ) {
		int (*postHookFunc) (int retVal___, int key, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_search_petDB_index_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_search_petDB_index_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, type);
		}
	}
	return retVal___;
}
int HP_pet_hungry_timer_delete(struct pet_data *pd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.hungry_timer_delete(pd);
	}
	if( HPMHooks.count.HP_pet_hungry_timer_delete_post ) {
		int (*postHookFunc) (int retVal___, struct pet_data *pd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_hungry_timer_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_hungry_timer_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pd);
		}
	}
	return retVal___;
}
int HP_pet_performance(struct map_session_data *sd, struct pet_data *pd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.performance(sd, pd);
	}
	if( HPMHooks.count.HP_pet_performance_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct pet_data *pd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_performance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_performance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, pd);
		}
	}
	return retVal___;
}
int HP_pet_return_egg(struct map_session_data *sd, struct pet_data *pd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.return_egg(sd, pd);
	}
	if( HPMHooks.count.HP_pet_return_egg_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct pet_data *pd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_return_egg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_return_egg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, pd);
		}
	}
	return retVal___;
}
int HP_pet_data_init(struct map_session_data *sd, struct s_pet *petinfo) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.data_init(sd, petinfo);
	}
	if( HPMHooks.count.HP_pet_data_init_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_pet *petinfo);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_data_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_data_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, petinfo);
		}
	}
	return retVal___;
}
int HP_pet_birth_process(struct map_session_data *sd, struct s_pet *petinfo) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.birth_process(sd, petinfo);
	}
	if( HPMHooks.count.HP_pet_birth_process_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct s_pet *petinfo);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_birth_process_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_birth_process_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, petinfo);
		}
	}
	return retVal___;
}
int HP_pet_recv_petdata(int account_id, struct s_pet *p, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.recv_petdata(account_id, p, flag);
	}
	if( HPMHooks.count.HP_pet_recv_petdata_post ) {
		int (*postHookFunc) (int retVal___, int account_id, struct s_pet *p, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recv_petdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_recv_petdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, p, flag);
		}
	}
	return retVal___;
}
int HP_pet_select_egg(struct map_session_data *sd, short egg_index) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.select_egg(sd, egg_index);
	}
	if( HPMHooks.count.HP_pet_select_egg_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, short egg_index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_select_egg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_select_egg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, egg_index);
		}
	}
	return retVal___;
}
int HP_pet_catch_process1(struct map_session_data *sd, int target_class) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.catch_process1(sd, target_class);
	}
	if( HPMHooks.count.HP_pet_catch_process1_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int target_class);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process1_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_catch_process1_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, target_class);
		}
	}
	return retVal___;
}
int HP_pet_catch_process2(struct map_session_data *sd, int target_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.catch_process2(sd, target_id);
	}
	if( HPMHooks.count.HP_pet_catch_process2_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int target_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_catch_process2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_catch_process2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, target_id);
		}
	}
	return retVal___;
}
bool HP_pet_get_egg(int account_id, short pet_class, int pet_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.get_egg(account_id, pet_class, pet_id);
	}
	if( HPMHooks.count.HP_pet_get_egg_post ) {
		bool (*postHookFunc) (bool retVal___, int account_id, short pet_class, int pet_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_get_egg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_get_egg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, account_id, pet_class, pet_id);
		}
	}
	return retVal___;
}
int HP_pet_unequipitem(struct map_session_data *sd, struct pet_data *pd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.unequipitem(sd, pd);
	}
	if( HPMHooks.count.HP_pet_unequipitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct pet_data *pd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_unequipitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_unequipitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, pd);
		}
	}
	return retVal___;
}
int HP_pet_food(struct map_session_data *sd, struct pet_data *pd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.food(sd, pd);
	}
	if( HPMHooks.count.HP_pet_food_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct pet_data *pd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_food_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_food_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, pd);
		}
	}
	return retVal___;
}
int HP_pet_ai_sub_hard_lootsearch(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.pet.ai_sub_hard_lootsearch(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_lootsearch_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_lootsearch_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_pet_menu(struct map_session_data *sd, int menunum) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.menu(sd, menunum);
	}
	if( HPMHooks.count.HP_pet_menu_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int menunum);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_menu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_menu_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, menunum);
		}
	}
	return retVal___;
}
int HP_pet_change_name(struct map_session_data *sd, const char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pet_change_name_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.change_name(sd, name);
	}
	if( HPMHooks.count.HP_pet_change_name_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_change_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name);
		}
	}
	return retVal___;
}
int HP_pet_change_name_ack(struct map_session_data *sd, const char *name, int flag) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_pet_change_name_ack_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.change_name_ack(sd, name, flag);
	}
	if( HPMHooks.count.HP_pet_change_name_ack_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const char *name, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_change_name_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_change_name_ack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name, flag);
		}
	}
	return retVal___;
}
int HP_pet_equipitem(struct map_session_data *sd, int index) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.equipitem(sd, index);
	}
	if( HPMHooks.count.HP_pet_equipitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_equipitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_equipitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index);
		}
	}
	return retVal___;
}
int HP_pet_randomwalk(struct pet_data *pd, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.randomwalk(pd, tick);
	}
	if( HPMHooks.count.HP_pet_randomwalk_post ) {
		int (*postHookFunc) (int retVal___, struct pet_data *pd, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_randomwalk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_randomwalk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pd, tick);
		}
	}
	return retVal___;
}
int HP_pet_ai_sub_hard(struct pet_data *pd, struct map_session_data *sd, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.ai_sub_hard(pd, sd, tick);
	}
	if( HPMHooks.count.HP_pet_ai_sub_hard_post ) {
		int (*postHookFunc) (int retVal___, struct pet_data *pd, struct map_session_data *sd, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_hard_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_ai_sub_hard_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pd, sd, tick);
		}
	}
	return retVal___;
}
int HP_pet_ai_sub_foreachclient(struct map_session_data *sd, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.pet.ai_sub_foreachclient(sd, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_pet_ai_sub_foreachclient_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_sub_foreachclient_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_pet_ai_sub_foreachclient_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_pet_ai_hard(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.ai_hard(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pet_ai_hard_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_ai_hard_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_ai_hard_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pet_delay_item_drop(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.delay_item_drop(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pet_delay_item_drop_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_delay_item_drop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_delay_item_drop_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pet_lootitem_drop(struct pet_data *pd, struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.lootitem_drop(pd, sd);
	}
	if( HPMHooks.count.HP_pet_lootitem_drop_post ) {
		int (*postHookFunc) (int retVal___, struct pet_data *pd, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_lootitem_drop_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_lootitem_drop_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pd, sd);
		}
	}
	return retVal___;
}
int HP_pet_skill_bonus_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.skill_bonus_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pet_skill_bonus_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_skill_bonus_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_skill_bonus_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pet_recovery_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.recovery_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pet_recovery_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_recovery_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_recovery_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pet_skill_support_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.skill_support_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_pet_skill_support_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_skill_support_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_skill_support_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_pet_read_db(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.pet.read_db();
	}
	if( HPMHooks.count.HP_pet_read_db_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_pet_read_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_pet_read_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
/* quest_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.quest.init(minimal);
	}
	if( HPMHooks.count.HP_quest_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.quest.final();
	}
	if( HPMHooks.count.HP_quest_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.quest.reload();
	}
	if( HPMHooks.count.HP_quest_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct quest_db* HP_quest_db(int quest_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.db(quest_id);
	}
	if( HPMHooks.count.HP_quest_db_post ) {
		struct quest_db* (*postHookFunc) (struct quest_db* retVal___, int quest_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, quest_id);
		}
	}
	return retVal___;
}
int HP_quest_pc_login(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_quest_pc_login_pre ) {
		int (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.pc_login(sd);
	}
	if( HPMHooks.count.HP_quest_pc_login_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_pc_login_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_pc_login_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_quest_add(struct map_session_data *sd, int quest_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_quest_add_pre ) {
		int (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.add(sd, quest_id);
	}
	if( HPMHooks.count.HP_quest_add_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int quest_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_add_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, quest_id);
		}
	}
	return retVal___;
}
int HP_quest_change(struct map_session_data *sd, int qid1, int qid2) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_quest_change_pre ) {
		int (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.change(sd, qid1, qid2);
	}
	if( HPMHooks.count.HP_quest_change_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int qid1, int qid2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_change_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_change_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, qid1, qid2);
		}
	}
	return retVal___;
}
int HP_quest_delete(struct map_session_data *sd, int quest_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_quest_delete_pre ) {
		int (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.delete(sd, quest_id);
	}
	if( HPMHooks.count.HP_quest_delete_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int quest_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, quest_id);
		}
	}
	return retVal___;
}
int HP_quest_update_objective_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.quest.update_objective_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_quest_update_objective_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_quest_update_objective_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_quest_update_objective(struct map_session_data *sd, int mob_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_quest_update_objective_pre ) {
		void (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.quest.update_objective(sd, mob_id);
	}
	if( HPMHooks.count.HP_quest_update_objective_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int mob_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_objective_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_update_objective_post[hIndex].func;
			postHookFunc(sd, mob_id);
		}
	}
	return;
}
int HP_quest_update_status(struct map_session_data *sd, int quest_id, enum quest_state qs) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_quest_update_status_pre ) {
		int (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.update_status(sd, quest_id, qs);
	}
	if( HPMHooks.count.HP_quest_update_status_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int quest_id, enum quest_state qs);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_update_status_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_update_status_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, quest_id, qs);
		}
	}
	return retVal___;
}
int HP_quest_check(struct map_session_data *sd, int quest_id, enum quest_check_type type) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_quest_check_pre ) {
		int (*preHookFunc) (struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.check(sd, quest_id, type);
	}
	if( HPMHooks.count.HP_quest_check_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int quest_id, enum quest_check_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, quest_id, type);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.quest.clear();
	}
	if( HPMHooks.count.HP_quest_clear_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_clear_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_quest_read_db(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.read_db();
	}
	if( HPMHooks.count.HP_quest_read_db_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_read_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_read_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
struct quest_db* HP_quest_read_db_sub(struct config_setting_t *cs, int n, const char *source) {
	int hIndex = 0;
	struct quest_db* retVal___ = NULL;
	if( HPMHooks.count.HP_quest_read_db_sub_pre ) {
		struct quest_db* (*preHookFunc) (struct config_setting_t **cs, int *n, const char **source);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_read_db_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_quest_read_db_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&cs, &n, &source);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.quest.read_db_sub(cs, n, source);
	}
	if( HPMHooks.count.HP_quest_read_db_sub_post ) {
		struct quest_db* (*postHookFunc) (struct quest_db* retVal___, struct config_setting_t *cs, int n, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_quest_read_db_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_quest_read_db_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, cs, n, source);
		}
	}
	return retVal___;
}
/* rnd_interface */
void HP_rnd_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_rnd_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_rnd_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.rnd.init();
	}
	if( HPMHooks.count.HP_rnd_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_rnd_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_rnd_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_rnd_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_rnd_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.rnd.final();
	}
	if( HPMHooks.count.HP_rnd_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_rnd_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_rnd_seed(uint32 seed) {
	int hIndex = 0;
	if( HPMHooks.count.HP_rnd_seed_pre ) {
		void (*preHookFunc) (uint32 *seed);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_seed_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_rnd_seed_pre[hIndex].func;
			preHookFunc(&seed);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.rnd.seed(seed);
	}
	if( HPMHooks.count.HP_rnd_seed_post ) {
		void (*postHookFunc) (uint32 seed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_seed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_rnd_seed_post[hIndex].func;
			postHookFunc(seed);
		}
	}
	return;
}
int32 HP_rnd_random(void) {
	int hIndex = 0;
	int32 retVal___ = 0;
	if( HPMHooks.count.HP_rnd_random_pre ) {
		int32 (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_random_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_rnd_random_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.rnd.random();
	}
	if( HPMHooks.count.HP_rnd_random_post ) {
		int32 (*postHookFunc) (int32 retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_random_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_rnd_random_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
uint32 HP_rnd_roll(uint32 dice_faces) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_rnd_roll_pre ) {
		uint32 (*preHookFunc) (uint32 *dice_faces);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_roll_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_rnd_roll_pre[hIndex].func;
			retVal___ = preHookFunc(&dice_faces);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.rnd.roll(dice_faces);
	}
	if( HPMHooks.count.HP_rnd_roll_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, uint32 dice_faces);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_roll_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_rnd_roll_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, dice_faces);
		}
	}
	return retVal___;
}
int32 HP_rnd_value(int32 min, int32 max) {
	int hIndex = 0;
	int32 retVal___ = 0;
	if( HPMHooks.count.HP_rnd_value_pre ) {
		int32 (*preHookFunc) (int32 *min, int32 *max);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_value_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_rnd_value_pre[hIndex].func;
			retVal___ = preHookFunc(&min, &max);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.rnd.value(min, max);
	}
	if( HPMHooks.count.HP_rnd_value_post ) {
		int32 (*postHookFunc) (int32 retVal___, int32 min, int32 max);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_value_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_rnd_value_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, min, max);
		}
	}
	return retVal___;
}
double HP_rnd_uniform(void) {
	int hIndex = 0;
	double retVal___ = 0.;
	if( HPMHooks.count.HP_rnd_uniform_pre ) {
		double (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_uniform_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_rnd_uniform_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.rnd.uniform();
	}
	if( HPMHooks.count.HP_rnd_uniform_post ) {
		double (*postHookFunc) (double retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_uniform_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_rnd_uniform_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
double HP_rnd_uniform53(void) {
	int hIndex = 0;
	double retVal___ = 0.;
	if( HPMHooks.count.HP_rnd_uniform53_pre ) {
		double (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_uniform53_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_rnd_uniform53_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.rnd.uniform53();
	}
	if( HPMHooks.count.HP_rnd_uniform53_post ) {
		double (*postHookFunc) (double retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_rnd_uniform53_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_rnd_uniform53_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
/* script_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.init(minimal);
	}
	if( HPMHooks.count.HP_script_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.final();
	}
	if( HPMHooks.count.HP_script_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_script_reload(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.reload();
	}
	if( HPMHooks.count.HP_script_reload_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_reload_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
struct script_code* HP_script_parse(const char *src, const char *file, int line, int options, int *retval) {
	int hIndex = 0;
	struct script_code* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_pre ) {
		struct script_code* (*preHookFunc) (const char **src, const char **file, int *line, int *options, int **retval);
		*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, &retval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse(src, file, line, options, retval);
	}
	if( HPMHooks.count.HP_script_parse_post ) {
		struct script_code* (*postHookFunc) (struct script_code* retVal___, const char *src, const char *file, int line, int options, int *retval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, file, line, options, retval);
		}
	}
	return retVal___;
}
bool HP_script_add_builtin(const struct script_function *buildin, bool override) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.add_builtin(buildin, override);
	}
	if( HPMHooks.count.HP_script_add_builtin_post ) {
		bool (*postHookFunc) (bool retVal___, const struct script_function *buildin, bool override);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_builtin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_add_builtin_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, buildin, override);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.parse_builtin();
	}
	if( HPMHooks.count.HP_script_parse_builtin_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_builtin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_builtin_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
const char* HP_script_parse_subexpr(const char *p, int limit) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_subexpr_pre ) {
		const char* (*preHookFunc) (const char **p, int *limit);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_subexpr(p, limit);
	}
	if( HPMHooks.count.HP_script_parse_subexpr_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p, int limit);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_subexpr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_subexpr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, limit);
		}
	}
	return retVal___;
}
const char* HP_script_skip_space(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_skip_space_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.skip_space(p);
	}
	if( HPMHooks.count.HP_script_skip_space_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_skip_space_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_skip_space_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
void HP_script_error(const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_error_pre ) {
		void (*preHookFunc) (const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.error(src, file, start_line, error_msg, error_pos);
	}
	if( HPMHooks.count.HP_script_error_post ) {
		void (*postHookFunc) (const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_error_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_error_post[hIndex].func;
			postHookFunc(src, file, start_line, error_msg, error_pos);
		}
	}
	return;
}
void HP_script_warning(const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_warning_pre ) {
		void (*preHookFunc) (const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.warning(src, file, start_line, error_msg, error_pos);
	}
	if( HPMHooks.count.HP_script_warning_post ) {
		void (*postHookFunc) (const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_warning_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_warning_post[hIndex].func;
			postHookFunc(src, file, start_line, error_msg, error_pos);
		}
	}
	return;
}
bool HP_script_addScript(char *name, char *args, bool ( *func ) (struct script_state *st), bool isDeprecated) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_script_addScript_pre ) {
		bool (*preHookFunc) (char **name, char **args, bool ( **func ) (struct script_state *st), bool *isDeprecated);
		*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, &isDeprecated);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.addScript(name, args, func, isDeprecated);
	}
	if( HPMHooks.count.HP_script_addScript_post ) {
		bool (*postHookFunc) (bool retVal___, char *name, char *args, bool ( *func ) (struct script_state *st), bool isDeprecated);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addScript_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_addScript_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, args, func, isDeprecated);
		}
	}
	return retVal___;
}
int HP_script_conv_num(struct script_state *st, struct script_data *data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.conv_num(st, data);
	}
	if( HPMHooks.count.HP_script_conv_num_post ) {
		int (*postHookFunc) (int retVal___, struct script_state *st, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_conv_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_conv_num_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, data);
		}
	}
	return retVal___;
}
const char* HP_script_conv_str(struct script_state *st, struct script_data *data) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_conv_str_pre ) {
		const char* (*preHookFunc) (struct script_state **st, struct script_data **data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.conv_str(st, data);
	}
	if( HPMHooks.count.HP_script_conv_str_post ) {
		const char* (*postHookFunc) (const char* retVal___, struct script_state *st, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_conv_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_conv_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, data);
		}
	}
	return retVal___;
}
struct map_session_data* HP_script_rid2sd(struct script_state *st) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_rid2sd_pre ) {
		struct map_session_data* (*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.rid2sd(st);
	}
	if( HPMHooks.count.HP_script_rid2sd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_rid2sd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_rid2sd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st);
		}
	}
	return retVal___;
}
struct map_session_data* HP_script_id2sd(struct script_state *st, int account_id) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_id2sd_pre ) {
		struct map_session_data* (*preHookFunc) (struct script_state **st, int *account_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_id2sd_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_id2sd_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &account_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.id2sd(st, account_id);
	}
	if( HPMHooks.count.HP_script_id2sd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct script_state *st, int account_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_id2sd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_id2sd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, account_id);
		}
	}
	return retVal___;
}
struct map_session_data* HP_script_charid2sd(struct script_state *st, int char_id) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_charid2sd_pre ) {
		struct map_session_data* (*preHookFunc) (struct script_state **st, int *char_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_charid2sd_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_charid2sd_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &char_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.charid2sd(st, char_id);
	}
	if( HPMHooks.count.HP_script_charid2sd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct script_state *st, int char_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_charid2sd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_charid2sd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, char_id);
		}
	}
	return retVal___;
}
struct map_session_data* HP_script_nick2sd(struct script_state *st, const char *name) {
	int hIndex = 0;
	struct map_session_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_nick2sd_pre ) {
		struct map_session_data* (*preHookFunc) (struct script_state **st, const char **name);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_nick2sd_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_nick2sd_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.nick2sd(st, name);
	}
	if( HPMHooks.count.HP_script_nick2sd_post ) {
		struct map_session_data* (*postHookFunc) (struct map_session_data* retVal___, struct script_state *st, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_nick2sd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_nick2sd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, name);
		}
	}
	return retVal___;
}
void HP_script_detach_rid(struct script_state *st) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_detach_rid_pre ) {
		void (*preHookFunc) (struct script_state **st);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.detach_rid(st);
	}
	if( HPMHooks.count.HP_script_detach_rid_post ) {
		void (*postHookFunc) (struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_rid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_detach_rid_post[hIndex].func;
			postHookFunc(st);
		}
	}
	return;
}
struct script_data* HP_script_push_val(struct script_stack *stack, enum c_op type, int64 val, struct reg_db *ref) {
	int hIndex = 0;
	struct script_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_push_val_pre ) {
		struct script_data* (*preHookFunc) (struct script_stack **stack, enum c_op *type, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.push_val(stack, type, val, ref);
	}
	if( HPMHooks.count.HP_script_push_val_post ) {
		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, enum c_op type, int64 val, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_val_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_push_val_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, stack, type, val, ref);
		}
	}
	return retVal___;
}
struct script_data* HP_script_get_val(struct script_state *st, struct script_data *data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val(st, data);
	}
	if( HPMHooks.count.HP_script_get_val_post ) {
		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_state *st, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, data);
		}
	}
	return retVal___;
}
char* HP_script_get_val_ref_str(struct script_state *st, struct reg_db *n, struct script_data *data) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_get_val_ref_str_pre ) {
		char* (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_ref_str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_val_ref_str_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &n, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val_ref_str(st, n, data);
	}
	if( HPMHooks.count.HP_script_get_val_ref_str_post ) {
		char* (*postHookFunc) (char* retVal___, struct script_state *st, struct reg_db *n, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_ref_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_ref_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, n, data);
		}
	}
	return retVal___;
}
char* HP_script_get_val_scope_str(struct script_state *st, struct reg_db *n, struct script_data *data) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_get_val_scope_str_pre ) {
		char* (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_scope_str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_val_scope_str_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &n, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val_scope_str(st, n, data);
	}
	if( HPMHooks.count.HP_script_get_val_scope_str_post ) {
		char* (*postHookFunc) (char* retVal___, struct script_state *st, struct reg_db *n, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_scope_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_scope_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, n, data);
		}
	}
	return retVal___;
}
char* HP_script_get_val_npc_str(struct script_state *st, struct reg_db *n, struct script_data *data) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_get_val_npc_str_pre ) {
		char* (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_npc_str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_val_npc_str_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &n, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val_npc_str(st, n, data);
	}
	if( HPMHooks.count.HP_script_get_val_npc_str_post ) {
		char* (*postHookFunc) (char* retVal___, struct script_state *st, struct reg_db *n, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_npc_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_npc_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, n, data);
		}
	}
	return retVal___;
}
char* HP_script_get_val_instance_str(struct script_state *st, const char *name, struct script_data *data) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_get_val_instance_str_pre ) {
		char* (*preHookFunc) (struct script_state **st, const char **name, struct script_data **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_instance_str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_val_instance_str_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &name, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val_instance_str(st, name, data);
	}
	if( HPMHooks.count.HP_script_get_val_instance_str_post ) {
		char* (*postHookFunc) (char* retVal___, struct script_state *st, const char *name, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_instance_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_instance_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, name, data);
		}
	}
	return retVal___;
}
int HP_script_get_val_ref_num(struct script_state *st, struct reg_db *n, struct script_data *data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_get_val_ref_num_pre ) {
		int (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_ref_num_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_val_ref_num_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &n, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val_ref_num(st, n, data);
	}
	if( HPMHooks.count.HP_script_get_val_ref_num_post ) {
		int (*postHookFunc) (int retVal___, struct script_state *st, struct reg_db *n, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_ref_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_ref_num_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, n, data);
		}
	}
	return retVal___;
}
int HP_script_get_val_scope_num(struct script_state *st, struct reg_db *n, struct script_data *data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_get_val_scope_num_pre ) {
		int (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_scope_num_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_val_scope_num_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &n, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val_scope_num(st, n, data);
	}
	if( HPMHooks.count.HP_script_get_val_scope_num_post ) {
		int (*postHookFunc) (int retVal___, struct script_state *st, struct reg_db *n, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_scope_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_scope_num_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, n, data);
		}
	}
	return retVal___;
}
int HP_script_get_val_npc_num(struct script_state *st, struct reg_db *n, struct script_data *data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_get_val_npc_num_pre ) {
		int (*preHookFunc) (struct script_state **st, struct reg_db **n, struct script_data **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_npc_num_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_val_npc_num_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &n, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val_npc_num(st, n, data);
	}
	if( HPMHooks.count.HP_script_get_val_npc_num_post ) {
		int (*postHookFunc) (int retVal___, struct script_state *st, struct reg_db *n, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_npc_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_npc_num_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, n, data);
		}
	}
	return retVal___;
}
int HP_script_get_val_instance_num(struct script_state *st, const char *name, struct script_data *data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_get_val_instance_num_pre ) {
		int (*preHookFunc) (struct script_state **st, const char **name, struct script_data **data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_instance_num_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_val_instance_num_pre[hIndex].func;
			retVal___ = preHookFunc(&st, &name, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val_instance_num(st, name, data);
	}
	if( HPMHooks.count.HP_script_get_val_instance_num_post ) {
		int (*postHookFunc) (int retVal___, struct script_state *st, const char *name, struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val_instance_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val_instance_num_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, name, data);
		}
	}
	return retVal___;
}
const void* HP_script_get_val2(struct script_state *st, int64 uid, struct reg_db *ref) {
	int hIndex = 0;
	const void* retVal___ = NULL;
	if( HPMHooks.count.HP_script_get_val2_pre ) {
		const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_val2(st, uid, ref);
	}
	if( HPMHooks.count.HP_script_get_val2_post ) {
		const void* (*postHookFunc) (const void* retVal___, struct script_state *st, int64 uid, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_val2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_val2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, uid, ref);
		}
	}
	return retVal___;
}
struct script_data* HP_script_push_str(struct script_stack *stack, char *str) {
	int hIndex = 0;
	struct script_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_push_str_pre ) {
		struct script_data* (*preHookFunc) (struct script_stack **stack, 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, &str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.push_str(stack, str);
	}
	if( HPMHooks.count.HP_script_push_str_post ) {
		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_push_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, stack, str);
		}
	}
	return retVal___;
}
struct script_data* HP_script_push_conststr(struct script_stack *stack, const char *str) {
	int hIndex = 0;
	struct script_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_push_conststr_pre ) {
		struct script_data* (*preHookFunc) (struct script_stack **stack, const char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_conststr_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_push_conststr_pre[hIndex].func;
			retVal___ = preHookFunc(&stack, &str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.push_conststr(stack, str);
	}
	if( HPMHooks.count.HP_script_push_conststr_post ) {
		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_conststr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_push_conststr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, stack, str);
		}
	}
	return retVal___;
}
struct script_data* HP_script_push_copy(struct script_stack *stack, int pos) {
	int hIndex = 0;
	struct script_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_push_copy_pre ) {
		struct script_data* (*preHookFunc) (struct script_stack **stack, int *pos);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.push_copy(stack, pos);
	}
	if( HPMHooks.count.HP_script_push_copy_post ) {
		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_copy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_push_copy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, stack, pos);
		}
	}
	return retVal___;
}
void HP_script_pop_stack(struct script_state *st, int start, int end) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_pop_stack_pre ) {
		void (*preHookFunc) (struct script_state **st, int *start, int *end);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.pop_stack(st, start, end);
	}
	if( HPMHooks.count.HP_script_pop_stack_post ) {
		void (*postHookFunc) (struct script_state *st, int start, int end);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_pop_stack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_pop_stack_post[hIndex].func;
			postHookFunc(st, start, end);
		}
	}
	return;
}
void HP_script_set_constant(const char *name, int value, bool is_parameter, bool is_deprecated) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_constant_pre ) {
		void (*preHookFunc) (const char **name, int *value, bool *is_parameter, bool *is_deprecated);
		*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, &is_parameter, &is_deprecated);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_constant(name, value, is_parameter, is_deprecated);
	}
	if( HPMHooks.count.HP_script_set_constant_post ) {
		void (*postHookFunc) (const char *name, int value, bool is_parameter, bool is_deprecated);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_constant_post[hIndex].func;
			postHookFunc(name, value, is_parameter, is_deprecated);
		}
	}
	return;
}
void HP_script_set_constant2(const char *name, int value, bool is_parameter, bool is_deprecated) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_constant2_pre ) {
		void (*preHookFunc) (const char **name, int *value, bool *is_parameter, bool *is_deprecated);
		*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, &is_parameter, &is_deprecated);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_constant2(name, value, is_parameter, is_deprecated);
	}
	if( HPMHooks.count.HP_script_set_constant2_post ) {
		void (*postHookFunc) (const char *name, int value, bool is_parameter, bool is_deprecated);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_constant2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_constant2_post[hIndex].func;
			postHookFunc(name, value, is_parameter, is_deprecated);
		}
	}
	return;
}
bool HP_script_get_constant(const char *name, int *value) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_constant(name, value);
	}
	if( HPMHooks.count.HP_script_get_constant_post ) {
		bool (*postHookFunc) (bool retVal___, const char *name, int *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_constant_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_constant_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name, value);
		}
	}
	return retVal___;
}
void HP_script_label_add(int key, int pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_label_add_pre ) {
		void (*preHookFunc) (int *key, int *pos);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.label_add(key, pos);
	}
	if( HPMHooks.count.HP_script_label_add_post ) {
		void (*postHookFunc) (int key, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_label_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_label_add_post[hIndex].func;
			postHookFunc(key, pos);
		}
	}
	return;
}
void HP_script_run(struct script_code *rootscript, int pos, int rid, int oid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_run_pre ) {
		void (*preHookFunc) (struct script_code **rootscript, int *pos, int *rid, int *oid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.run(rootscript, pos, rid, oid);
	}
	if( HPMHooks.count.HP_script_run_post ) {
		void (*postHookFunc) (struct script_code *rootscript, int pos, int rid, int oid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_post[hIndex].func;
			postHookFunc(rootscript, pos, rid, oid);
		}
	}
	return;
}
void HP_script_run_npc(struct script_code *rootscript, int pos, int rid, int oid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_run_npc_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_npc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_run_npc_pre[hIndex].func;
			preHookFunc(&rootscript, &pos, &rid, &oid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.run_npc(rootscript, pos, rid, oid);
	}
	if( HPMHooks.count.HP_script_run_npc_post ) {
		void (*postHookFunc) (struct script_code *rootscript, int pos, int rid, int oid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_npc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_npc_post[hIndex].func;
			postHookFunc(rootscript, pos, rid, oid);
		}
	}
	return;
}
void HP_script_run_pet(struct script_code *rootscript, int pos, int rid, int oid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_run_pet_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_pet_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_run_pet_pre[hIndex].func;
			preHookFunc(&rootscript, &pos, &rid, &oid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.run_pet(rootscript, pos, rid, oid);
	}
	if( HPMHooks.count.HP_script_run_pet_post ) {
		void (*postHookFunc) (struct script_code *rootscript, int pos, int rid, int oid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_pet_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_pet_post[hIndex].func;
			postHookFunc(rootscript, pos, rid, oid);
		}
	}
	return;
}
void HP_script_run_main(struct script_state *st) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_run_main_pre ) {
		void (*preHookFunc) (struct script_state **st);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.run_main(st);
	}
	if( HPMHooks.count.HP_script_run_main_post ) {
		void (*postHookFunc) (struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_main_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_main_post[hIndex].func;
			postHookFunc(st);
		}
	}
	return;
}
int HP_script_run_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.run_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_script_run_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_script_set_var(struct map_session_data *sd, char *name, void *val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.set_var(sd, name, val);
	}
	if( HPMHooks.count.HP_script_set_var_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, char *name, void *val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_var_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_var_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, name, val);
		}
	}
	return retVal___;
}
void HP_script_stop_instances(struct script_code *code) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_stop_instances_pre ) {
		void (*preHookFunc) (struct script_code **code);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.stop_instances(code);
	}
	if( HPMHooks.count.HP_script_stop_instances_post ) {
		void (*postHookFunc) (struct script_code *code);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stop_instances_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_stop_instances_post[hIndex].func;
			postHookFunc(code);
		}
	}
	return;
}
void HP_script_free_code(struct script_code *code) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_free_code_pre ) {
		void (*preHookFunc) (struct script_code **code);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.free_code(code);
	}
	if( HPMHooks.count.HP_script_free_code_post ) {
		void (*postHookFunc) (struct script_code *code);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_code_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_free_code_post[hIndex].func;
			postHookFunc(code);
		}
	}
	return;
}
void HP_script_free_vars(struct DBMap *var_storage) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_free_vars_pre ) {
		void (*preHookFunc) (struct DBMap **var_storage);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.free_vars(var_storage);
	}
	if( HPMHooks.count.HP_script_free_vars_post ) {
		void (*postHookFunc) (struct DBMap *var_storage);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_vars_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_free_vars_post[hIndex].func;
			postHookFunc(var_storage);
		}
	}
	return;
}
struct script_state* HP_script_alloc_state(struct script_code *rootscript, int pos, int rid, int oid) {
	int hIndex = 0;
	struct script_state* retVal___ = NULL;
	if( HPMHooks.count.HP_script_alloc_state_pre ) {
		struct script_state* (*preHookFunc) (struct script_code **rootscript, int *pos, int *rid, int *oid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.alloc_state(rootscript, pos, rid, oid);
	}
	if( HPMHooks.count.HP_script_alloc_state_post ) {
		struct script_state* (*postHookFunc) (struct script_state* retVal___, struct script_code *rootscript, int pos, int rid, int oid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_alloc_state_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_alloc_state_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, rootscript, pos, rid, oid);
		}
	}
	return retVal___;
}
void HP_script_free_state(struct script_state *st) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_free_state_pre ) {
		void (*preHookFunc) (struct script_state **st);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.free_state(st);
	}
	if( HPMHooks.count.HP_script_free_state_post ) {
		void (*postHookFunc) (struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_free_state_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_free_state_post[hIndex].func;
			postHookFunc(st);
		}
	}
	return;
}
void HP_script_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.add_pending_ref(st, ref);
	}
	if( HPMHooks.count.HP_script_add_pending_ref_post ) {
		void (*postHookFunc) (struct script_state *st, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_pending_ref_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_add_pending_ref_post[hIndex].func;
			postHookFunc(st, ref);
		}
	}
	return;
}
void HP_script_run_autobonus(const char *autobonus, int id, int pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_run_autobonus_pre ) {
		void (*preHookFunc) (const char **autobonus, int *id, int *pos);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.run_autobonus(autobonus, id, pos);
	}
	if( HPMHooks.count.HP_script_run_autobonus_post ) {
		void (*postHookFunc) (const char *autobonus, int id, int pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_autobonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_autobonus_post[hIndex].func;
			postHookFunc(autobonus, id, pos);
		}
	}
	return;
}
void HP_script_cleararray_pc(struct map_session_data *sd, const char *varname, void *value) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_cleararray_pc_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **varname, void **value);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.cleararray_pc(sd, varname, value);
	}
	if( HPMHooks.count.HP_script_cleararray_pc_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *varname, void *value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_cleararray_pc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_cleararray_pc_post[hIndex].func;
			postHookFunc(sd, varname, value);
		}
	}
	return;
}
void HP_script_setarray_pc(struct map_session_data *sd, const char *varname, uint32 idx, void *value, int *refcache) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_setarray_pc_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **varname, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.setarray_pc(sd, varname, idx, value, refcache);
	}
	if( HPMHooks.count.HP_script_setarray_pc_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *varname, uint32 idx, void *value, int *refcache);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setarray_pc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_setarray_pc_post[hIndex].func;
			postHookFunc(sd, varname, idx, value, refcache);
		}
	}
	return;
}
bool HP_script_config_read(const char *filename, bool imported) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_script_config_read_pre ) {
		bool (*preHookFunc) (const char **filename, bool *imported);
		*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(&filename, &imported);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.config_read(filename, imported);
	}
	if( HPMHooks.count.HP_script_config_read_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename, bool imported);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_config_read_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename, imported);
		}
	}
	return retVal___;
}
int HP_script_add_str(const char *p) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.add_str(p);
	}
	if( HPMHooks.count.HP_script_add_str_post ) {
		int (*postHookFunc) (int retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_add_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_get_str(int id) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_get_str_pre ) {
		const char* (*preHookFunc) (int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_str(id);
	}
	if( HPMHooks.count.HP_script_get_str_post ) {
		const char* (*postHookFunc) (const char* retVal___, int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, id);
		}
	}
	return retVal___;
}
int HP_script_search_str(const char *p) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.search_str(p);
	}
	if( HPMHooks.count.HP_script_search_str_post ) {
		int (*postHookFunc) (int retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_search_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_search_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
void HP_script_setd_sub(struct script_state *st, struct map_session_data *sd, const char *varname, int elem, const void *value, struct reg_db *ref) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_setd_sub_pre ) {
		void (*preHookFunc) (struct script_state **st, struct map_session_data **sd, const char **varname, int *elem, const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.setd_sub(st, sd, varname, elem, value, ref);
	}
	if( HPMHooks.count.HP_script_setd_sub_post ) {
		void (*postHookFunc) (struct script_state *st, struct map_session_data *sd, const char *varname, int elem, const void *value, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_setd_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_setd_sub_post[hIndex].func;
			postHookFunc(st, sd, varname, elem, value, ref);
		}
	}
	return;
}
void HP_script_attach_state(struct script_state *st) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_attach_state_pre ) {
		void (*preHookFunc) (struct script_state **st);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.attach_state(st);
	}
	if( HPMHooks.count.HP_script_attach_state_post ) {
		void (*postHookFunc) (struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_attach_state_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_attach_state_post[hIndex].func;
			postHookFunc(st);
		}
	}
	return;
}
struct script_queue* HP_script_queue(int idx) {
	int hIndex = 0;
	struct script_queue* retVal___ = NULL;
	if( HPMHooks.count.HP_script_queue_pre ) {
		struct script_queue* (*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.queue(idx);
	}
	if( HPMHooks.count.HP_script_queue_post ) {
		struct script_queue* (*postHookFunc) (struct script_queue* retVal___, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_queue_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, idx);
		}
	}
	return retVal___;
}
bool HP_script_queue_add(int idx, int var) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.queue_add(idx, var);
	}
	if( HPMHooks.count.HP_script_queue_add_post ) {
		bool (*postHookFunc) (bool retVal___, int idx, int var);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_queue_add_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, idx, var);
		}
	}
	return retVal___;
}
bool HP_script_queue_del(int idx) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.queue_del(idx);
	}
	if( HPMHooks.count.HP_script_queue_del_post ) {
		bool (*postHookFunc) (bool retVal___, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_del_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_queue_del_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, idx);
		}
	}
	return retVal___;
}
bool HP_script_queue_remove(int idx, int var) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.queue_remove(idx, var);
	}
	if( HPMHooks.count.HP_script_queue_remove_post ) {
		bool (*postHookFunc) (bool retVal___, int idx, int var);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_queue_remove_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, idx, var);
		}
	}
	return retVal___;
}
int HP_script_queue_create(void) {
	int hIndex = 0;
	int retVal___ = 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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.queue_create();
	}
	if( HPMHooks.count.HP_script_queue_create_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_queue_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_script_queue_clear(int idx) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_script_queue_clear_pre ) {
		bool (*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;
			retVal___ = preHookFunc(&idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.queue_clear(idx);
	}
	if( HPMHooks.count.HP_script_queue_clear_post ) {
		bool (*postHookFunc) (bool retVal___, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_queue_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_queue_clear_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, idx);
		}
	}
	return retVal___;
}
const char* HP_script_parse_curly_close(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_curly_close_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_curly_close(p);
	}
	if( HPMHooks.count.HP_script_parse_curly_close_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_curly_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_curly_close_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_syntax_close(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_syntax_close_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_syntax_close(p);
	}
	if( HPMHooks.count.HP_script_parse_syntax_close_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_syntax_close_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_syntax_close_sub(const char *p, int *flag) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_syntax_close_sub_pre ) {
		const char* (*preHookFunc) (const char **p, int **flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_syntax_close_sub(p, flag);
	}
	if( HPMHooks.count.HP_script_parse_syntax_close_sub_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_close_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_syntax_close_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, flag);
		}
	}
	return retVal___;
}
const char* HP_script_parse_syntax(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_syntax_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_syntax(p);
	}
	if( HPMHooks.count.HP_script_parse_syntax_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_syntax_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_syntax_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
c_op HP_script_get_com(const struct script_buf *scriptbuf, int *pos) {
	int hIndex = 0;
	c_op retVal___ = C_NOP;
	if( HPMHooks.count.HP_script_get_com_pre ) {
		c_op (*preHookFunc) (const struct script_buf **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_com(scriptbuf, pos);
	}
	if( HPMHooks.count.HP_script_get_com_post ) {
		c_op (*postHookFunc) (c_op retVal___, const struct script_buf *scriptbuf, int *pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_com_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_com_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, scriptbuf, pos);
		}
	}
	return retVal___;
}
int HP_script_get_num(const struct script_buf *scriptbuf, int *pos) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_get_num_pre ) {
		int (*preHookFunc) (const struct script_buf **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_num(scriptbuf, pos);
	}
	if( HPMHooks.count.HP_script_get_num_post ) {
		int (*postHookFunc) (int retVal___, const struct script_buf *scriptbuf, int *pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_num_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, scriptbuf, pos);
		}
	}
	return retVal___;
}
const char* HP_script_op2name(int op) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_op2name_pre ) {
		const char* (*preHookFunc) (int *op);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.op2name(op);
	}
	if( HPMHooks.count.HP_script_op2name_post ) {
		const char* (*postHookFunc) (const char* retVal___, int op);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op2name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_op2name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, op);
		}
	}
	return retVal___;
}
void HP_script_reportsrc(struct script_state *st) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_reportsrc_pre ) {
		void (*preHookFunc) (struct script_state **st);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.reportsrc(st);
	}
	if( HPMHooks.count.HP_script_reportsrc_post ) {
		void (*postHookFunc) (struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportsrc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_reportsrc_post[hIndex].func;
			postHookFunc(st);
		}
	}
	return;
}
void HP_script_reportdata(struct script_data *data) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_reportdata_pre ) {
		void (*preHookFunc) (struct script_data **data);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.reportdata(data);
	}
	if( HPMHooks.count.HP_script_reportdata_post ) {
		void (*postHookFunc) (struct script_data *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_reportdata_post[hIndex].func;
			postHookFunc(data);
		}
	}
	return;
}
void HP_script_reportfunc(struct script_state *st) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_reportfunc_pre ) {
		void (*preHookFunc) (struct script_state **st);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.reportfunc(st);
	}
	if( HPMHooks.count.HP_script_reportfunc_post ) {
		void (*postHookFunc) (struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reportfunc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_reportfunc_post[hIndex].func;
			postHookFunc(st);
		}
	}
	return;
}
void HP_script_disp_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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.disp_warning_message(mes, pos);
	}
	if( HPMHooks.count.HP_script_disp_warning_message_post ) {
		void (*postHookFunc) (const char *mes, const char *pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_disp_warning_message_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_disp_warning_message_post[hIndex].func;
			postHookFunc(mes, pos);
		}
	}
	return;
}
void HP_script_check_event(struct script_state *st, const char *evt) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_check_event_pre ) {
		void (*preHookFunc) (struct script_state **st, const char **evt);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.check_event(st, evt);
	}
	if( HPMHooks.count.HP_script_check_event_post ) {
		void (*postHookFunc) (struct script_state *st, const char *evt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_event_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_check_event_post[hIndex].func;
			postHookFunc(st, evt);
		}
	}
	return;
}
unsigned int HP_script_calc_hash(const char *p) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.calc_hash(p);
	}
	if( HPMHooks.count.HP_script_calc_hash_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_calc_hash_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_calc_hash_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
void HP_script_addb(int a) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_addb_pre ) {
		void (*preHookFunc) (int *a);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.addb(a);
	}
	if( HPMHooks.count.HP_script_addb_post ) {
		void (*postHookFunc) (int a);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_addb_post[hIndex].func;
			postHookFunc(a);
		}
	}
	return;
}
void HP_script_addc(int a) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_addc_pre ) {
		void (*preHookFunc) (int *a);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.addc(a);
	}
	if( HPMHooks.count.HP_script_addc_post ) {
		void (*postHookFunc) (int a);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_addc_post[hIndex].func;
			postHookFunc(a);
		}
	}
	return;
}
void HP_script_addi(int a) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_addi_pre ) {
		void (*preHookFunc) (int *a);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.addi(a);
	}
	if( HPMHooks.count.HP_script_addi_post ) {
		void (*postHookFunc) (int a);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addi_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_addi_post[hIndex].func;
			postHookFunc(a);
		}
	}
	return;
}
void HP_script_addl(int l) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_addl_pre ) {
		void (*preHookFunc) (int *l);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.addl(l);
	}
	if( HPMHooks.count.HP_script_addl_post ) {
		void (*postHookFunc) (int l);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_addl_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_addl_post[hIndex].func;
			postHookFunc(l);
		}
	}
	return;
}
void HP_script_set_label(int l, int pos, const char *script_pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_label_pre ) {
		void (*preHookFunc) (int *l, int *pos, const char **script_pos);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_label(l, pos, script_pos);
	}
	if( HPMHooks.count.HP_script_set_label_post ) {
		void (*postHookFunc) (int l, int pos, const char *script_pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_label_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_label_post[hIndex].func;
			postHookFunc(l, pos, script_pos);
		}
	}
	return;
}
const char* HP_script_skip_word(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_skip_word_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.skip_word(p);
	}
	if( HPMHooks.count.HP_script_skip_word_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_skip_word_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_skip_word_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
int HP_script_add_word(const char *p) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.add_word(p);
	}
	if( HPMHooks.count.HP_script_add_word_post ) {
		int (*postHookFunc) (int retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_word_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_add_word_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_callfunc(const char *p, int require_paren, int is_custom) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_callfunc_pre ) {
		const char* (*preHookFunc) (const char **p, int *require_paren, int *is_custom);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_callfunc(p, require_paren, is_custom);
	}
	if( HPMHooks.count.HP_script_parse_callfunc_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p, int require_paren, int is_custom);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_callfunc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_callfunc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p, require_paren, is_custom);
		}
	}
	return retVal___;
}
void HP_script_parse_nextline(bool first, const char *p) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_parse_nextline_pre ) {
		void (*preHookFunc) (bool *first, const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.parse_nextline(first, p);
	}
	if( HPMHooks.count.HP_script_parse_nextline_post ) {
		void (*postHookFunc) (bool first, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_nextline_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_nextline_post[hIndex].func;
			postHookFunc(first, p);
		}
	}
	return;
}
const char* HP_script_parse_variable(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_variable_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_variable(p);
	}
	if( HPMHooks.count.HP_script_parse_variable_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_variable_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_variable_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_simpleexpr(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_simpleexpr_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_simpleexpr(p);
	}
	if( HPMHooks.count.HP_script_parse_simpleexpr_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_simpleexpr_paren(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_simpleexpr_paren_pre ) {
		const char* (*preHookFunc) (const char **p);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_paren_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_paren_pre[hIndex].func;
			retVal___ = preHookFunc(&p);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_simpleexpr_paren(p);
	}
	if( HPMHooks.count.HP_script_parse_simpleexpr_paren_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_paren_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_paren_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_simpleexpr_number(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_simpleexpr_number_pre ) {
		const char* (*preHookFunc) (const char **p);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_number_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_number_pre[hIndex].func;
			retVal___ = preHookFunc(&p);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_simpleexpr_number(p);
	}
	if( HPMHooks.count.HP_script_parse_simpleexpr_number_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_number_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_number_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_simpleexpr_string(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_simpleexpr_string_pre ) {
		const char* (*preHookFunc) (const char **p);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_string_pre[hIndex].func;
			retVal___ = preHookFunc(&p);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_simpleexpr_string(p);
	}
	if( HPMHooks.count.HP_script_parse_simpleexpr_string_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_string_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_simpleexpr_name(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_simpleexpr_name_pre ) {
		const char* (*preHookFunc) (const char **p);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_name_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_name_pre[hIndex].func;
			retVal___ = preHookFunc(&p);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_simpleexpr_name(p);
	}
	if( HPMHooks.count.HP_script_parse_simpleexpr_name_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_simpleexpr_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_simpleexpr_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
void HP_script_add_translatable_string(const struct script_string_buf *string, const char *start_point) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_add_translatable_string_pre ) {
		void (*preHookFunc) (const struct script_string_buf **string, const char **start_point);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_translatable_string_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_add_translatable_string_pre[hIndex].func;
			preHookFunc(&string, &start_point);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.add_translatable_string(string, start_point);
	}
	if( HPMHooks.count.HP_script_add_translatable_string_post ) {
		void (*postHookFunc) (const struct script_string_buf *string, const char *start_point);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_translatable_string_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_add_translatable_string_post[hIndex].func;
			postHookFunc(string, start_point);
		}
	}
	return;
}
const char* HP_script_parse_expr(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_expr_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_expr(p);
	}
	if( HPMHooks.count.HP_script_parse_expr_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_expr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_expr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
const char* HP_script_parse_line(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_parse_line_pre ) {
		const char* (*preHookFunc) (const char **p);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_line(p);
	}
	if( HPMHooks.count.HP_script_parse_line_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_line_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_line_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
void HP_script_read_constdb(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_read_constdb_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.read_constdb();
	}
	if( HPMHooks.count.HP_script_read_constdb_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_read_constdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_read_constdb_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_script_constdb_comment(const char *comment) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_constdb_comment_pre ) {
		void (*preHookFunc) (const char **comment);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_constdb_comment_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_constdb_comment_pre[hIndex].func;
			preHookFunc(&comment);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.constdb_comment(comment);
	}
	if( HPMHooks.count.HP_script_constdb_comment_post ) {
		void (*postHookFunc) (const char *comment);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_constdb_comment_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_constdb_comment_post[hIndex].func;
			postHookFunc(comment);
		}
	}
	return;
}
void HP_script_load_parameters(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_load_parameters_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_parameters_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_load_parameters_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.load_parameters();
	}
	if( HPMHooks.count.HP_script_load_parameters_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_parameters_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_load_parameters_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
const char* HP_script_print_line(StringBuf *buf, const char *p, const char *mark, int line) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_print_line_pre ) {
		const char* (*preHookFunc) (StringBuf **buf, const char **p, const char **mark, int *line);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.print_line(buf, p, mark, line);
	}
	if( HPMHooks.count.HP_script_print_line_post ) {
		const char* (*postHookFunc) (const char* retVal___, StringBuf *buf, const char *p, const char *mark, int line);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_print_line_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_print_line_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, buf, p, mark, line);
		}
	}
	return retVal___;
}
void HP_script_errorwarning_sub(StringBuf *buf, const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_errorwarning_sub_pre ) {
		void (*preHookFunc) (StringBuf **buf, const char **src, const char **file, int *start_line, const char **error_msg, const char **error_pos);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.errorwarning_sub(buf, src, file, start_line, error_msg, error_pos);
	}
	if( HPMHooks.count.HP_script_errorwarning_sub_post ) {
		void (*postHookFunc) (StringBuf *buf, const char *src, const char *file, int start_line, const char *error_msg, const char *error_pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_errorwarning_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_errorwarning_sub_post[hIndex].func;
			postHookFunc(buf, src, file, start_line, error_msg, error_pos);
		}
	}
	return;
}
int HP_script_set_reg(struct script_state *st, struct map_session_data *sd, int64 num, const char *name, const void *value, struct reg_db *ref) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_set_reg_pre ) {
		int (*preHookFunc) (struct script_state **st, struct map_session_data **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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.set_reg(st, sd, num, name, value, ref);
	}
	if( HPMHooks.count.HP_script_set_reg_post ) {
		int (*postHookFunc) (int retVal___, struct script_state *st, struct map_session_data *sd, int64 num, const char *name, const void *value, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, sd, num, name, value, ref);
		}
	}
	return retVal___;
}
void HP_script_set_reg_ref_str(struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_reg_ref_str_pre ) {
		void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_ref_str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_set_reg_ref_str_pre[hIndex].func;
			preHookFunc(&st, &n, &num, &name, &str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_reg_ref_str(st, n, num, name, str);
	}
	if( HPMHooks.count.HP_script_set_reg_ref_str_post ) {
		void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_ref_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_ref_str_post[hIndex].func;
			postHookFunc(st, n, num, name, str);
		}
	}
	return;
}
void HP_script_set_reg_scope_str(struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_reg_scope_str_pre ) {
		void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_scope_str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_set_reg_scope_str_pre[hIndex].func;
			preHookFunc(&st, &n, &num, &name, &str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_reg_scope_str(st, n, num, name, str);
	}
	if( HPMHooks.count.HP_script_set_reg_scope_str_post ) {
		void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_scope_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_scope_str_post[hIndex].func;
			postHookFunc(st, n, num, name, str);
		}
	}
	return;
}
void HP_script_set_reg_npc_str(struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_reg_npc_str_pre ) {
		void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, const char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_npc_str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_set_reg_npc_str_pre[hIndex].func;
			preHookFunc(&st, &n, &num, &name, &str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_reg_npc_str(st, n, num, name, str);
	}
	if( HPMHooks.count.HP_script_set_reg_npc_str_post ) {
		void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_npc_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_npc_str_post[hIndex].func;
			postHookFunc(st, n, num, name, str);
		}
	}
	return;
}
void HP_script_set_reg_instance_str(struct script_state *st, int64 num, const char *name, const char *str) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_reg_instance_str_pre ) {
		void (*preHookFunc) (struct script_state **st, int64 *num, const char **name, const char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_instance_str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_set_reg_instance_str_pre[hIndex].func;
			preHookFunc(&st, &num, &name, &str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_reg_instance_str(st, num, name, str);
	}
	if( HPMHooks.count.HP_script_set_reg_instance_str_post ) {
		void (*postHookFunc) (struct script_state *st, int64 num, const char *name, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_instance_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_instance_str_post[hIndex].func;
			postHookFunc(st, num, name, str);
		}
	}
	return;
}
void HP_script_set_reg_ref_num(struct script_state *st, struct reg_db *n, int64 num, const char *name, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_reg_ref_num_pre ) {
		void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_ref_num_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_set_reg_ref_num_pre[hIndex].func;
			preHookFunc(&st, &n, &num, &name, &val);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_reg_ref_num(st, n, num, name, val);
	}
	if( HPMHooks.count.HP_script_set_reg_ref_num_post ) {
		void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_ref_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_ref_num_post[hIndex].func;
			postHookFunc(st, n, num, name, val);
		}
	}
	return;
}
void HP_script_set_reg_scope_num(struct script_state *st, struct reg_db *n, int64 num, const char *name, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_reg_scope_num_pre ) {
		void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_scope_num_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_set_reg_scope_num_pre[hIndex].func;
			preHookFunc(&st, &n, &num, &name, &val);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_reg_scope_num(st, n, num, name, val);
	}
	if( HPMHooks.count.HP_script_set_reg_scope_num_post ) {
		void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_scope_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_scope_num_post[hIndex].func;
			postHookFunc(st, n, num, name, val);
		}
	}
	return;
}
void HP_script_set_reg_npc_num(struct script_state *st, struct reg_db *n, int64 num, const char *name, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_reg_npc_num_pre ) {
		void (*preHookFunc) (struct script_state **st, struct reg_db **n, int64 *num, const char **name, int *val);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_npc_num_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_set_reg_npc_num_pre[hIndex].func;
			preHookFunc(&st, &n, &num, &name, &val);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_reg_npc_num(st, n, num, name, val);
	}
	if( HPMHooks.count.HP_script_set_reg_npc_num_post ) {
		void (*postHookFunc) (struct script_state *st, struct reg_db *n, int64 num, const char *name, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_npc_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_npc_num_post[hIndex].func;
			postHookFunc(st, n, num, name, val);
		}
	}
	return;
}
void HP_script_set_reg_instance_num(struct script_state *st, int64 num, const char *name, int val) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_set_reg_instance_num_pre ) {
		void (*preHookFunc) (struct script_state **st, int64 *num, const char **name, int *val);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_instance_num_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_set_reg_instance_num_pre[hIndex].func;
			preHookFunc(&st, &num, &name, &val);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.set_reg_instance_num(st, num, name, val);
	}
	if( HPMHooks.count.HP_script_set_reg_instance_num_post ) {
		void (*postHookFunc) (struct script_state *st, int64 num, const char *name, int val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_set_reg_instance_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_set_reg_instance_num_post[hIndex].func;
			postHookFunc(st, num, name, val);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.stack_expand(stack);
	}
	if( HPMHooks.count.HP_script_stack_expand_post ) {
		void (*postHookFunc) (struct script_stack *stack);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_stack_expand_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_stack_expand_post[hIndex].func;
			postHookFunc(stack);
		}
	}
	return;
}
struct script_data* HP_script_push_retinfo(struct script_stack *stack, struct script_retinfo *ri, struct reg_db *ref) {
	int hIndex = 0;
	struct script_data* retVal___ = NULL;
	if( HPMHooks.count.HP_script_push_retinfo_pre ) {
		struct script_data* (*preHookFunc) (struct script_stack **stack, struct script_retinfo **ri, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.push_retinfo(stack, ri, ref);
	}
	if( HPMHooks.count.HP_script_push_retinfo_post ) {
		struct script_data* (*postHookFunc) (struct script_data* retVal___, struct script_stack *stack, struct script_retinfo *ri, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_push_retinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_push_retinfo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, stack, ri, ref);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.op_3(st, op);
	}
	if( HPMHooks.count.HP_script_op_3_post ) {
		void (*postHookFunc) (struct script_state *st, int op);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_3_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_op_3_post[hIndex].func;
			postHookFunc(st, op);
		}
	}
	return;
}
void HP_script_op_2str(struct script_state *st, int op, const char *s1, const char *s2) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_op_2str_pre ) {
		void (*preHookFunc) (struct script_state **st, int *op, const char **s1, const char **s2);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.op_2str(st, op, s1, s2);
	}
	if( HPMHooks.count.HP_script_op_2str_post ) {
		void (*postHookFunc) (struct script_state *st, int op, const char *s1, const char *s2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_op_2str_post[hIndex].func;
			postHookFunc(st, op, s1, s2);
		}
	}
	return;
}
void HP_script_op_2num(struct script_state *st, int op, int i1, int i2) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_op_2num_pre ) {
		void (*preHookFunc) (struct script_state **st, int *op, int *i1, int *i2);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.op_2num(st, op, i1, i2);
	}
	if( HPMHooks.count.HP_script_op_2num_post ) {
		void (*postHookFunc) (struct script_state *st, int op, int i1, int i2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_op_2num_post[hIndex].func;
			postHookFunc(st, op, i1, i2);
		}
	}
	return;
}
void HP_script_op_2(struct script_state *st, int op) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_op_2_pre ) {
		void (*preHookFunc) (struct script_state **st, int *op);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.op_2(st, op);
	}
	if( HPMHooks.count.HP_script_op_2_post ) {
		void (*postHookFunc) (struct script_state *st, int op);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_op_2_post[hIndex].func;
			postHookFunc(st, op);
		}
	}
	return;
}
void HP_script_op_1(struct script_state *st, int op) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_op_1_pre ) {
		void (*preHookFunc) (struct script_state **st, int *op);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.op_1(st, op);
	}
	if( HPMHooks.count.HP_script_op_1_post ) {
		void (*postHookFunc) (struct script_state *st, int op);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_op_1_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_op_1_post[hIndex].func;
			postHookFunc(st, op);
		}
	}
	return;
}
bool HP_script_check_buildin_argtype(struct script_state *st, int func) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_script_check_buildin_argtype_pre ) {
		bool (*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;
			retVal___ = preHookFunc(&st, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.check_buildin_argtype(st, func);
	}
	if( HPMHooks.count.HP_script_check_buildin_argtype_post ) {
		bool (*postHookFunc) (bool retVal___, struct script_state *st, int func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_check_buildin_argtype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_check_buildin_argtype_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, func);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.detach_state(st, dequeue_event);
	}
	if( HPMHooks.count.HP_script_detach_state_post ) {
		void (*postHookFunc) (struct script_state *st, bool dequeue_event);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_detach_state_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_detach_state_post[hIndex].func;
			postHookFunc(st, dequeue_event);
		}
	}
	return;
}
int HP_script_db_free_code_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_db_free_code_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.db_free_code_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_db_free_code_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_db_free_code_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_db_free_code_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_script_add_autobonus(const char *autobonus) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_add_autobonus_pre ) {
		void (*preHookFunc) (const char **autobonus);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.add_autobonus(autobonus);
	}
	if( HPMHooks.count.HP_script_add_autobonus_post ) {
		void (*postHookFunc) (const char *autobonus);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_autobonus_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_add_autobonus_post[hIndex].func;
			postHookFunc(autobonus);
		}
	}
	return;
}
int HP_script_menu_countoptions(const char *str, int max_count, int *total) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.menu_countoptions(str, max_count, total);
	}
	if( HPMHooks.count.HP_script_menu_countoptions_post ) {
		int (*postHookFunc) (int retVal___, const char *str, int max_count, int *total);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_menu_countoptions_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_menu_countoptions_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, max_count, total);
		}
	}
	return retVal___;
}
int HP_script_buildin_areawarp_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_areawarp_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_areawarp_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_areawarp_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_areawarp_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_areapercentheal_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_areapercentheal_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_areapercentheal_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_areapercentheal_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_areapercentheal_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_script_buildin_delitem_delete(struct map_session_data *sd, int idx, int *amount, bool delete_items) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_buildin_delitem_delete_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *idx, int **amount, bool *delete_items);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.buildin_delitem_delete(sd, idx, amount, delete_items);
	}
	if( HPMHooks.count.HP_script_buildin_delitem_delete_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int idx, int *amount, bool delete_items);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_buildin_delitem_delete_post[hIndex].func;
			postHookFunc(sd, idx, amount, delete_items);
		}
	}
	return;
}
bool HP_script_buildin_delitem_search(struct map_session_data *sd, struct item *it, bool exact_match) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.buildin_delitem_search(sd, it, exact_match);
	}
	if( HPMHooks.count.HP_script_buildin_delitem_search_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, struct item *it, bool exact_match);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_delitem_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_buildin_delitem_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, it, exact_match);
		}
	}
	return retVal___;
}
int HP_script_buildin_killmonster_sub_strip(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_killmonster_sub_strip(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_killmonster_sub_strip_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonster_sub_strip_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_killmonster_sub_strip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_killmonster_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_killmonster_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_killmonster_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonster_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_killmonster_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_killmonsterall_sub_strip(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_killmonsterall_sub_strip(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonsterall_sub_strip_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_killmonsterall_sub_strip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_killmonsterall_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_killmonsterall_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_killmonsterall_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_killmonsterall_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_killmonsterall_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_announce_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_announce_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_announce_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_announce_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_announce_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_getareausers_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_getareausers_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_getareausers_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_getareausers_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_getareausers_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_getareadropitem_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_getareadropitem_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_getareadropitem_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_getareadropitem_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_getareadropitem_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_mapflag_pvp_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.mapflag_pvp_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_mapflag_pvp_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_mapflag_pvp_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_mapflag_pvp_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_pvpoff_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_pvpoff_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_pvpoff_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_pvpoff_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_pvpoff_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_maprespawnguildid_sub_pc(struct map_session_data *sd, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_maprespawnguildid_sub_pc(sd, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_pc_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_maprespawnguildid_sub_pc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_maprespawnguildid_sub_mob(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_maprespawnguildid_sub_mob(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_maprespawnguildid_sub_mob_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_maprespawnguildid_sub_mob_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_mobcount_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_mobcount_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_mobcount_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_mobcount_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_mobcount_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_playbgm_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.playbgm_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_playbgm_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_playbgm_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_playbgm_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_playbgm_foreachpc_sub(struct map_session_data *sd, va_list args) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&sd, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.script.playbgm_foreachpc_sub(sd, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_script_playbgm_foreachpc_sub_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_playbgm_foreachpc_sub_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_script_playbgm_foreachpc_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_script_soundeffect_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.soundeffect_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_soundeffect_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_soundeffect_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_soundeffect_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_query_sql_sub(struct script_state *st, struct Sql *handle) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_buildin_query_sql_sub_pre ) {
		int (*preHookFunc) (struct script_state **st, struct 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.buildin_query_sql_sub(st, handle);
	}
	if( HPMHooks.count.HP_script_buildin_query_sql_sub_post ) {
		int (*postHookFunc) (int retVal___, struct script_state *st, struct Sql *handle);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_query_sql_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_buildin_query_sql_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, handle);
		}
	}
	return retVal___;
}
int HP_script_buildin_instance_warpall_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_instance_warpall_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_instance_warpall_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_instance_warpall_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_instance_warpall_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_buildin_mobuseskill_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.buildin_mobuseskill_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_buildin_mobuseskill_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_buildin_mobuseskill_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_buildin_mobuseskill_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_cleanfloor_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.cleanfloor_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_cleanfloor_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_cleanfloor_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_cleanfloor_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_script_run_func(struct script_state *st) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.run_func(st);
	}
	if( HPMHooks.count.HP_script_run_func_post ) {
		int (*postHookFunc) (int retVal___, struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_func_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_func_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st);
		}
	}
	return retVal___;
}
const char* HP_script_getfuncname(struct script_state *st) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.getfuncname(st);
	}
	if( HPMHooks.count.HP_script_getfuncname_post ) {
		const char* (*postHookFunc) (const char* retVal___, struct script_state *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_getfuncname_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_getfuncname_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st);
		}
	}
	return retVal___;
}
unsigned int HP_script_calc_hash_ci(const char *p) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.calc_hash_ci(p);
	}
	if( HPMHooks.count.HP_script_calc_hash_ci_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_calc_hash_ci_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_calc_hash_ci_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
struct reg_db* HP_script_array_src(struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.array_src(st, sd, name, ref);
	}
	if( HPMHooks.count.HP_script_array_src_post ) {
		struct reg_db* (*postHookFunc) (struct reg_db* retVal___, struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_src_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_src_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, sd, name, ref);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.array_update(src, num, empty);
	}
	if( HPMHooks.count.HP_script_array_update_post ) {
		void (*postHookFunc) (struct reg_db *src, int64 num, bool empty);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_update_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_update_post[hIndex].func;
			postHookFunc(src, num, empty);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.array_delete(src, sa);
	}
	if( HPMHooks.count.HP_script_array_delete_post ) {
		void (*postHookFunc) (struct reg_db *src, struct script_array *sa);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_delete_post[hIndex].func;
			postHookFunc(src, sa);
		}
	}
	return;
}
void HP_script_array_remove_member(struct reg_db *src, struct script_array *sa, unsigned int idx) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.array_remove_member(src, sa, idx);
	}
	if( HPMHooks.count.HP_script_array_remove_member_post ) {
		void (*postHookFunc) (struct reg_db *src, struct script_array *sa, unsigned int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_remove_member_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_remove_member_post[hIndex].func;
			postHookFunc(src, sa, idx);
		}
	}
	return;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.array_add_member(sa, idx);
	}
	if( HPMHooks.count.HP_script_array_add_member_post ) {
		void (*postHookFunc) (struct script_array *sa, unsigned int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_add_member_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_add_member_post[hIndex].func;
			postHookFunc(sa, idx);
		}
	}
	return;
}
unsigned int HP_script_array_size(struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.array_size(st, sd, name, ref);
	}
	if( HPMHooks.count.HP_script_array_size_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_size_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_size_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, sd, name, ref);
		}
	}
	return retVal___;
}
unsigned int HP_script_array_highest_key(struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.array_highest_key(st, sd, name, ref);
	}
	if( HPMHooks.count.HP_script_array_highest_key_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, struct script_state *st, struct map_session_data *sd, const char *name, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_highest_key_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_highest_key_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, sd, name, ref);
		}
	}
	return retVal___;
}
int HP_script_array_free_db(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_array_free_db_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.array_free_db(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_array_free_db_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_free_db_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_array_free_db_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_script_array_ensure_zero(struct script_state *st, struct map_session_data *sd, int64 uid, struct reg_db *ref) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.array_ensure_zero(st, sd, uid, ref);
	}
	if( HPMHooks.count.HP_script_array_ensure_zero_post ) {
		void (*postHookFunc) (struct script_state *st, struct map_session_data *sd, int64 uid, struct reg_db *ref);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_ensure_zero_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_ensure_zero_post[hIndex].func;
			postHookFunc(st, sd, uid, ref);
		}
	}
	return;
}
void HP_script_reg_destroy_single(struct map_session_data *sd, int64 reg, struct script_reg_state *data) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.reg_destroy_single(sd, reg, data);
	}
	if( HPMHooks.count.HP_script_reg_destroy_single_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int64 reg, struct script_reg_state *data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reg_destroy_single_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_reg_destroy_single_post[hIndex].func;
			postHookFunc(sd, reg, data);
		}
	}
	return;
}
int HP_script_reg_destroy(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_reg_destroy_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.reg_destroy(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_reg_destroy_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_reg_destroy_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_reg_destroy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.generic_ui_array_expand(plus);
	}
	if( HPMHooks.count.HP_script_generic_ui_array_expand_post ) {
		void (*postHookFunc) (unsigned int plus);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_generic_ui_array_expand_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_generic_ui_array_expand_post[hIndex].func;
			postHookFunc(plus);
		}
	}
	return;
}
unsigned int* HP_script_array_cpy_list(struct script_array *sa) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.array_cpy_list(sa);
	}
	if( HPMHooks.count.HP_script_array_cpy_list_post ) {
		unsigned int* (*postHookFunc) (unsigned int* retVal___, struct script_array *sa);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_array_cpy_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_array_cpy_list_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sa);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.hardcoded_constants();
	}
	if( HPMHooks.count.HP_script_hardcoded_constants_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_hardcoded_constants_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_hardcoded_constants_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
unsigned short HP_script_mapindexname2id(struct script_state *st, const char *name) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.mapindexname2id(st, name);
	}
	if( HPMHooks.count.HP_script_mapindexname2id_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct script_state *st, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_mapindexname2id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_mapindexname2id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st, name);
		}
	}
	return retVal___;
}
int HP_script_string_dup(char *str) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_string_dup_pre ) {
		int (*preHookFunc) (char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_string_dup_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_string_dup_pre[hIndex].func;
			retVal___ = preHookFunc(&str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.string_dup(str);
	}
	if( HPMHooks.count.HP_script_string_dup_post ) {
		int (*postHookFunc) (int retVal___, char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_string_dup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_string_dup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
void HP_script_load_translations(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_load_translations_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_translations_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_load_translations_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.load_translations();
	}
	if( HPMHooks.count.HP_script_load_translations_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_translations_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_load_translations_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_script_load_translation_addstring(const char *file, uint8 lang_id, const char *msgctxt, const struct script_string_buf *msgid, const struct script_string_buf *msgstr) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_script_load_translation_addstring_pre ) {
		bool (*preHookFunc) (const char **file, uint8 *lang_id, const char **msgctxt, const struct script_string_buf **msgid, const struct script_string_buf **msgstr);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_translation_addstring_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_load_translation_addstring_pre[hIndex].func;
			retVal___ = preHookFunc(&file, &lang_id, &msgctxt, &msgid, &msgstr);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.load_translation_addstring(file, lang_id, msgctxt, msgid, msgstr);
	}
	if( HPMHooks.count.HP_script_load_translation_addstring_post ) {
		bool (*postHookFunc) (bool retVal___, const char *file, uint8 lang_id, const char *msgctxt, const struct script_string_buf *msgid, const struct script_string_buf *msgstr);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_translation_addstring_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_load_translation_addstring_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, file, lang_id, msgctxt, msgid, msgstr);
		}
	}
	return retVal___;
}
int HP_script_load_translation(const char *file, uint8 lang_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_load_translation_pre ) {
		int (*preHookFunc) (const char **file, uint8 *lang_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_translation_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_load_translation_pre[hIndex].func;
			retVal___ = preHookFunc(&file, &lang_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.load_translation(file, lang_id);
	}
	if( HPMHooks.count.HP_script_load_translation_post ) {
		int (*postHookFunc) (int retVal___, const char *file, uint8 lang_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_load_translation_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_load_translation_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, file, lang_id);
		}
	}
	return retVal___;
}
int HP_script_translation_db_destroyer(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_translation_db_destroyer_pre ) {
		int (*preHookFunc) (union DBKey *key, struct DBData **data, va_list ap);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_translation_db_destroyer_pre; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			preHookFunc = HPMHooks.list.HP_script_translation_db_destroyer_pre[hIndex].func;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.script.translation_db_destroyer(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_script_translation_db_destroyer_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_translation_db_destroyer_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_script_translation_db_destroyer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_script_clear_translations(bool reload) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_clear_translations_pre ) {
		void (*preHookFunc) (bool *reload);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_clear_translations_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_clear_translations_pre[hIndex].func;
			preHookFunc(&reload);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.clear_translations(reload);
	}
	if( HPMHooks.count.HP_script_clear_translations_post ) {
		void (*postHookFunc) (bool reload);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_clear_translations_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_clear_translations_post[hIndex].func;
			postHookFunc(reload);
		}
	}
	return;
}
int HP_script_parse_cleanup_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_script_parse_cleanup_timer_pre ) {
		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_cleanup_timer_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_parse_cleanup_timer_pre[hIndex].func;
			retVal___ = preHookFunc(&tid, &tick, &id, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.parse_cleanup_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_script_parse_cleanup_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parse_cleanup_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parse_cleanup_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
uint8 HP_script_add_language(const char *name) {
	int hIndex = 0;
	uint8 retVal___ = 0;
	if( HPMHooks.count.HP_script_add_language_pre ) {
		uint8 (*preHookFunc) (const char **name);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_language_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_add_language_pre[hIndex].func;
			retVal___ = preHookFunc(&name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.add_language(name);
	}
	if( HPMHooks.count.HP_script_add_language_post ) {
		uint8 (*postHookFunc) (uint8 retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_add_language_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_add_language_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
const char* HP_script_get_translation_file_name(const char *file) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_script_get_translation_file_name_pre ) {
		const char* (*preHookFunc) (const char **file);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_translation_file_name_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_get_translation_file_name_pre[hIndex].func;
			retVal___ = preHookFunc(&file);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.script.get_translation_file_name(file);
	}
	if( HPMHooks.count.HP_script_get_translation_file_name_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *file);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_get_translation_file_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_get_translation_file_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, file);
		}
	}
	return retVal___;
}
void HP_script_parser_clean_leftovers(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_parser_clean_leftovers_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parser_clean_leftovers_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_parser_clean_leftovers_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.parser_clean_leftovers();
	}
	if( HPMHooks.count.HP_script_parser_clean_leftovers_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_parser_clean_leftovers_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_parser_clean_leftovers_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_script_run_use_script(struct map_session_data *sd, struct item_data *data, int oid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_run_use_script_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct item_data **data, int *oid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_use_script_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_run_use_script_pre[hIndex].func;
			preHookFunc(&sd, &data, &oid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.run_use_script(sd, data, oid);
	}
	if( HPMHooks.count.HP_script_run_use_script_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int oid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_use_script_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_use_script_post[hIndex].func;
			postHookFunc(sd, data, oid);
		}
	}
	return;
}
void HP_script_run_item_equip_script(struct map_session_data *sd, struct item_data *data, int oid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_run_item_equip_script_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct item_data **data, int *oid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_equip_script_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_run_item_equip_script_pre[hIndex].func;
			preHookFunc(&sd, &data, &oid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.run_item_equip_script(sd, data, oid);
	}
	if( HPMHooks.count.HP_script_run_item_equip_script_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int oid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_equip_script_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_item_equip_script_post[hIndex].func;
			postHookFunc(sd, data, oid);
		}
	}
	return;
}
void HP_script_run_item_unequip_script(struct map_session_data *sd, struct item_data *data, int oid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_script_run_item_unequip_script_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct item_data **data, int *oid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_unequip_script_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_script_run_item_unequip_script_pre[hIndex].func;
			preHookFunc(&sd, &data, &oid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.script.run_item_unequip_script(sd, data, oid);
	}
	if( HPMHooks.count.HP_script_run_item_unequip_script_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct item_data *data, int oid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_script_run_item_unequip_script_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_script_run_item_unequip_script_post[hIndex].func;
			postHookFunc(sd, data, oid);
		}
	}
	return;
}
/* searchstore_interface */
bool HP_searchstore_open(struct map_session_data *sd, unsigned int uses, unsigned short effect) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.searchstore.open(sd, uses, effect);
	}
	if( HPMHooks.count.HP_searchstore_open_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int uses, unsigned short effect);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_open_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, uses, effect);
		}
	}
	return retVal___;
}
void HP_searchstore_query(struct map_session_data *sd, unsigned char type, unsigned int min_price, unsigned int max_price, const unsigned short *itemlist, unsigned int item_count, const unsigned short *cardlist, unsigned int card_count) {
	int hIndex = 0;
	if( HPMHooks.count.HP_searchstore_query_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned char *type, unsigned int *min_price, unsigned int *max_price, const unsigned short **itemlist, unsigned int *item_count, const unsigned short **cardlist, unsigned int *card_count);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.searchstore.query(sd, type, min_price, max_price, itemlist, item_count, cardlist, card_count);
	}
	if( HPMHooks.count.HP_searchstore_query_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned char type, unsigned int min_price, unsigned int max_price, const unsigned short *itemlist, unsigned int item_count, const unsigned short *cardlist, unsigned int card_count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_query_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_query_post[hIndex].func;
			postHookFunc(sd, type, min_price, max_price, itemlist, item_count, cardlist, card_count);
		}
	}
	return;
}
bool HP_searchstore_querynext(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.searchstore.querynext(sd);
	}
	if( HPMHooks.count.HP_searchstore_querynext_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_querynext_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_querynext_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
void HP_searchstore_next(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_searchstore_next_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.searchstore.next(sd);
	}
	if( HPMHooks.count.HP_searchstore_next_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_next_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_next_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_searchstore_clear(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_searchstore_clear_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.searchstore.clear(sd);
	}
	if( HPMHooks.count.HP_searchstore_clear_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_clear_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_searchstore_close(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_searchstore_close_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.searchstore.close(sd);
	}
	if( HPMHooks.count.HP_searchstore_close_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_close_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_searchstore_click(struct map_session_data *sd, int account_id, int store_id, unsigned short nameid) {
	int hIndex = 0;
	if( HPMHooks.count.HP_searchstore_click_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *account_id, int *store_id, unsigned short *nameid);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.searchstore.click(sd, account_id, store_id, nameid);
	}
	if( HPMHooks.count.HP_searchstore_click_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int account_id, int store_id, unsigned short nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_click_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_click_post[hIndex].func;
			postHookFunc(sd, account_id, store_id, nameid);
		}
	}
	return;
}
bool HP_searchstore_queryremote(struct map_session_data *sd, int account_id) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.searchstore.queryremote(sd, account_id);
	}
	if( HPMHooks.count.HP_searchstore_queryremote_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, int account_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_queryremote_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_queryremote_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, account_id);
		}
	}
	return retVal___;
}
void HP_searchstore_clearremote(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_searchstore_clearremote_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.searchstore.clearremote(sd);
	}
	if( HPMHooks.count.HP_searchstore_clearremote_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_clearremote_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_clearremote_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
bool HP_searchstore_result(struct map_session_data *sd, unsigned int store_id, int account_id, const char *store_name, unsigned short nameid, unsigned short amount, unsigned int price, const short *card, unsigned char refine) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.searchstore.result(sd, store_id, account_id, store_name, nameid, amount, price, card, refine);
	}
	if( HPMHooks.count.HP_searchstore_result_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned int store_id, int account_id, const char *store_name, unsigned short nameid, unsigned short amount, unsigned int price, const short *card, unsigned char refine);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_searchstore_result_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_searchstore_result_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, store_id, account_id, store_name, nameid, amount, price, card, refine);
		}
	}
	return retVal___;
}
/* showmsg_interface */
void HP_showmsg_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_showmsg_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_showmsg_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.showmsg.init();
	}
	if( HPMHooks.count.HP_showmsg_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_showmsg_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_showmsg_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_showmsg_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_showmsg_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.showmsg.final();
	}
	if( HPMHooks.count.HP_showmsg_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_showmsg_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_showmsg_clearScreen(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_showmsg_clearScreen_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_clearScreen_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_showmsg_clearScreen_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.showmsg.clearScreen();
	}
	if( HPMHooks.count.HP_showmsg_clearScreen_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_clearScreen_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_showmsg_clearScreen_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_showmsg_showMessageV(const char *string, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_showmsg_showMessageV_pre ) {
		int (*preHookFunc) (const char **string, va_list ap);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_pre; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			preHookFunc = HPMHooks.list.HP_showmsg_showMessageV_pre[hIndex].func;
			retVal___ = preHookFunc(&string, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.showmsg.showMessageV(string, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_showmsg_showMessageV_post ) {
		int (*postHookFunc) (int retVal___, const char *string, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_showmsg_showMessageV_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_showmsg_showMessageV_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, string, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
/* skill_interface */
int HP_skill_init(bool minimal) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.init(minimal);
	}
	if( HPMHooks.count.HP_skill_init_post ) {
		int (*postHookFunc) (int retVal___, bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, minimal);
		}
	}
	return retVal___;
}
int HP_skill_final(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.final();
	}
	if( HPMHooks.count.HP_skill_final_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_skill_reload(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_reload_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_reload_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_reload_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.reload();
	}
	if( HPMHooks.count.HP_skill_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_skill_read_db(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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.read_db(minimal);
	}
	if( HPMHooks.count.HP_skill_read_db_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_read_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_read_db_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
int HP_skill_get_index(uint16 skill_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_index(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_index_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_index_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_index_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_type(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_type(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_type_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_type_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_hit(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_hit(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_hit_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_hit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_hit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_inf(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_inf(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_inf_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_inf_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_inf_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_ele(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_ele(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_ele_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ele_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_ele_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_nk(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_nk(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_nk_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_nk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_nk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_max(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_max(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_max_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_max_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_max_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_range(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_range(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_range_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_range_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_range2(struct block_list *bl, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_range2(bl, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_range2_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_range2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_range2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_splash(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_splash(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_splash_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_splash_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_splash_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_hp(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_hp(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_hp_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_hp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_hp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_mhp(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_mhp(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_mhp_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_mhp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_mhp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_sp(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_sp(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_sp_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_sp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_sp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_state(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_state(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_state_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_state_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_state_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_spiritball(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_spiritball(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_spiritball_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_spiritball_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_spiritball_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_zeny(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_zeny(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_zeny_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_zeny_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_zeny_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_num(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_num(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_num_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_num_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_num_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_cast(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_cast(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_cast_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_cast_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_cast_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_delay(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_delay(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_delay_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_delay_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_delay_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_walkdelay(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_walkdelay(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_walkdelay_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_walkdelay_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_walkdelay_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_time(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_time(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_time_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_time_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_time_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_time2(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_time2(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_time2_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_time2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_time2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_castnodex(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_castnodex(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_castnodex_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castnodex_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_castnodex_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_delaynodex(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_delaynodex(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_delaynodex_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_delaynodex_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_delaynodex_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_castdef(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_castdef(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_castdef_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castdef_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_castdef_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_weapontype(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_weapontype(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_weapontype_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_weapontype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_weapontype_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_ammotype(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_ammotype(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_ammotype_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ammotype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_ammotype_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_ammo_qty(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_ammo_qty(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_ammo_qty_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_ammo_qty_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_ammo_qty_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_unit_id(uint16 skill_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_unit_id(skill_id, flag);
	}
	if( HPMHooks.count.HP_skill_get_unit_id_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_unit_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, flag);
		}
	}
	return retVal___;
}
int HP_skill_get_inf2(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_inf2(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_inf2_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_inf2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_inf2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_castcancel(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_castcancel(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_castcancel_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_castcancel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_castcancel_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_maxcount(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_maxcount(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_maxcount_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_maxcount_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_maxcount_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_blewcount(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_blewcount(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_blewcount_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_blewcount_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_blewcount_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_unit_flag(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_unit_flag(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_unit_flag_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_flag_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_unit_flag_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_unit_target(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_unit_target(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_unit_target_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_unit_target_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_unit_interval(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_unit_interval(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_unit_interval_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_interval_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_unit_interval_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_unit_bl_target(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_unit_bl_target(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_unit_bl_target_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_bl_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_unit_bl_target_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_unit_layout_type(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_unit_layout_type(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_unit_layout_type_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_unit_layout_type_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_unit_range(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_unit_range(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_unit_range_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_range_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_unit_range_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_get_cooldown(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_cooldown(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_cooldown_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_cooldown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_cooldown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_tree_get_max(uint16 skill_id, int b_class) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.tree_get_max(skill_id, b_class);
	}
	if( HPMHooks.count.HP_skill_tree_get_max_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, int b_class);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_tree_get_max_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_tree_get_max_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, b_class);
		}
	}
	return retVal___;
}
const char* HP_skill_get_name(uint16 skill_id) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_get_name_pre ) {
		const char* (*preHookFunc) (uint16 *skill_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_name(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_name_post ) {
		const char* (*postHookFunc) (const char* retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
const char* HP_skill_get_desc(uint16 skill_id) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_get_desc_pre ) {
		const char* (*preHookFunc) (uint16 *skill_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_desc(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_desc_post ) {
		const char* (*postHookFunc) (const char* retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_desc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_desc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
void HP_skill_chk(uint16 *skill_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_chk_pre ) {
		void (*preHookFunc) (uint16 **skill_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.chk(skill_id);
	}
	if( HPMHooks.count.HP_skill_chk_post ) {
		void (*postHookFunc) (uint16 *skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_chk_post[hIndex].func;
			postHookFunc(skill_id);
		}
	}
	return;
}
int HP_skill_get_casttype(uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_casttype(skill_id);
	}
	if( HPMHooks.count.HP_skill_get_casttype_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_casttype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_casttype_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_get_casttype2(uint16 index) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_casttype2(index);
	}
	if( HPMHooks.count.HP_skill_get_casttype2_post ) {
		int (*postHookFunc) (int retVal___, uint16 index);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_casttype2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_casttype2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, index);
		}
	}
	return retVal___;
}
bool HP_skill_is_combo(int skill_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.is_combo(skill_id);
	}
	if( HPMHooks.count.HP_skill_is_combo_post ) {
		bool (*postHookFunc) (bool retVal___, int skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_is_combo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_is_combo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_name2id(const char *name) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.name2id(name);
	}
	if( HPMHooks.count.HP_skill_name2id_post ) {
		int (*postHookFunc) (int retVal___, const char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_name2id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_name2id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, name);
		}
	}
	return retVal___;
}
int HP_skill_isammotype(struct map_session_data *sd, int skill_id) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.isammotype(sd, skill_id);
	}
	if( HPMHooks.count.HP_skill_isammotype_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_isammotype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_isammotype_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_castend_id(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_id(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_skill_castend_id_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_skill_castend_pos(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_pos(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_skill_castend_pos_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_pos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_skill_castend_map(struct map_session_data *sd, uint16 skill_id, const char *mapname) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_map(sd, skill_id, mapname);
	}
	if( HPMHooks.count.HP_skill_castend_map_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, const char *mapname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_map_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_map_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, mapname);
		}
	}
	return retVal___;
}
int HP_skill_cleartimerskill(struct block_list *src) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.cleartimerskill(src);
	}
	if( HPMHooks.count.HP_skill_cleartimerskill_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_cleartimerskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src);
		}
	}
	return retVal___;
}
int HP_skill_addtimerskill(struct block_list *src, int64 tick, int target, int x, int y, uint16 skill_id, uint16 skill_lv, int type, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.addtimerskill(src, tick, target, x, y, skill_id, skill_lv, type, flag);
	}
	if( HPMHooks.count.HP_skill_addtimerskill_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, int64 tick, int target, int x, int y, uint16 skill_id, uint16 skill_lv, int type, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_addtimerskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_addtimerskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, tick, target, x, y, skill_id, skill_lv, type, flag);
		}
	}
	return retVal___;
}
int HP_skill_additional_effect(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int dmg_lv, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.additional_effect(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick);
	}
	if( HPMHooks.count.HP_skill_additional_effect_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int dmg_lv, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_additional_effect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick);
		}
	}
	return retVal___;
}
int HP_skill_counter_additional_effect(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.counter_additional_effect(src, bl, skill_id, skill_lv, attack_type, tick);
	}
	if( HPMHooks.count.HP_skill_counter_additional_effect_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int attack_type, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, attack_type, tick);
		}
	}
	return retVal___;
}
int HP_skill_blown(struct block_list *src, struct block_list *target, int count, int8 dir, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.blown(src, target, count, dir, flag);
	}
	if( HPMHooks.count.HP_skill_blown_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int count, int8 dir, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_blown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, count, dir, flag);
		}
	}
	return retVal___;
}
int HP_skill_break_equip(struct block_list *bl, unsigned short where, int rate, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.break_equip(bl, where, rate, flag);
	}
	if( HPMHooks.count.HP_skill_break_equip_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned short where, int rate, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_break_equip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_break_equip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, where, rate, flag);
		}
	}
	return retVal___;
}
int HP_skill_strip_equip(struct block_list *bl, unsigned short where, int rate, int lv, int time) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.strip_equip(bl, where, rate, lv, time);
	}
	if( HPMHooks.count.HP_skill_strip_equip_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned short where, int rate, int lv, int time);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_strip_equip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_strip_equip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, where, rate, lv, time);
		}
	}
	return retVal___;
}
struct skill_unit_group* HP_skill_id2group(int group_id) {
	int hIndex = 0;
	struct skill_unit_group* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_id2group_pre ) {
		struct skill_unit_group* (*preHookFunc) (int *group_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.id2group(group_id);
	}
	if( HPMHooks.count.HP_skill_id2group_post ) {
		struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, int group_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_id2group_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_id2group_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group_id);
		}
	}
	return retVal___;
}
struct skill_unit_group* HP_skill_unitsetting(struct block_list *src, uint16 skill_id, uint16 skill_lv, short x, short y, int flag) {
	int hIndex = 0;
	struct skill_unit_group* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_unitsetting_pre ) {
		struct skill_unit_group* (*preHookFunc) (struct block_list **src, uint16 *skill_id, uint16 *skill_lv, short *x, short *y, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unitsetting(src, skill_id, skill_lv, x, y, flag);
	}
	if( HPMHooks.count.HP_skill_unitsetting_post ) {
		struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *src, uint16 skill_id, uint16 skill_lv, short x, short y, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unitsetting_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, skill_id, skill_lv, x, y, flag);
		}
	}
	return retVal___;
}
struct skill_unit* HP_skill_initunit(struct skill_unit_group *group, int idx, int x, int y, int val1, int val2) {
	int hIndex = 0;
	struct skill_unit* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_initunit_pre ) {
		struct skill_unit* (*preHookFunc) (struct skill_unit_group **group, int *idx, int *x, int *y, int *val1, int *val2);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.initunit(group, idx, x, y, val1, val2);
	}
	if( HPMHooks.count.HP_skill_initunit_post ) {
		struct skill_unit* (*postHookFunc) (struct skill_unit* retVal___, struct skill_unit_group *group, int idx, int x, int y, int val1, int val2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_initunit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_initunit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group, idx, x, y, val1, val2);
		}
	}
	return retVal___;
}
int HP_skill_delunit(struct skill_unit *su) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.delunit(su);
	}
	if( HPMHooks.count.HP_skill_delunit_post ) {
		int (*postHookFunc) (int retVal___, struct skill_unit *su);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delunit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_delunit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, su);
		}
	}
	return retVal___;
}
struct skill_unit_group* HP_skill_init_unitgroup(struct block_list *src, int count, uint16 skill_id, uint16 skill_lv, int unit_id, int limit, int interval) {
	int hIndex = 0;
	struct skill_unit_group* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_init_unitgroup_pre ) {
		struct skill_unit_group* (*preHookFunc) (struct block_list **src, int *count, uint16 *skill_id, uint16 *skill_lv, int *unit_id, int *limit, int *interval);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.init_unitgroup(src, count, skill_id, skill_lv, unit_id, limit, interval);
	}
	if( HPMHooks.count.HP_skill_init_unitgroup_post ) {
		struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *src, int count, uint16 skill_id, uint16 skill_lv, int unit_id, int limit, int interval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unitgroup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_init_unitgroup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, count, skill_id, skill_lv, unit_id, limit, interval);
		}
	}
	return retVal___;
}
int HP_skill_del_unitgroup(struct skill_unit_group *group, const char *file, int line, const char *func) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.del_unitgroup(group, file, line, func);
	}
	if( HPMHooks.count.HP_skill_del_unitgroup_post ) {
		int (*postHookFunc) (int retVal___, struct skill_unit_group *group, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_del_unitgroup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_del_unitgroup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group, file, line, func);
		}
	}
	return retVal___;
}
int HP_skill_clear_unitgroup(struct block_list *src) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.clear_unitgroup(src);
	}
	if( HPMHooks.count.HP_skill_clear_unitgroup_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_unitgroup_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_clear_unitgroup_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src);
		}
	}
	return retVal___;
}
int HP_skill_clear_group(struct block_list *bl, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.clear_group(bl, flag);
	}
	if( HPMHooks.count.HP_skill_clear_group_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_clear_group_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_clear_group_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, flag);
		}
	}
	return retVal___;
}
int HP_skill_unit_onplace(struct skill_unit *src, struct block_list *bl, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unit_onplace(src, bl, tick);
	}
	if( HPMHooks.count.HP_skill_unit_onplace_post ) {
		int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_onplace_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, tick);
		}
	}
	return retVal___;
}
int HP_skill_unit_ondamaged(struct skill_unit *src, struct block_list *bl, int64 damage, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unit_ondamaged(src, bl, damage, tick);
	}
	if( HPMHooks.count.HP_skill_unit_ondamaged_post ) {
		int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 damage, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_ondamaged_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_ondamaged_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, damage, tick);
		}
	}
	return retVal___;
}
int HP_skill_cast_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.cast_fix(bl, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_cast_fix_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_cast_fix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_cast_fix_sc(struct block_list *bl, int time) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.cast_fix_sc(bl, time);
	}
	if( HPMHooks.count.HP_skill_cast_fix_sc_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int time);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cast_fix_sc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_cast_fix_sc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, time);
		}
	}
	return retVal___;
}
int HP_skill_vf_cast_fix(struct block_list *bl, double time, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.vf_cast_fix(bl, time, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_vf_cast_fix_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, double time, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_vf_cast_fix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_vf_cast_fix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, time, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_delay_fix(struct block_list *bl, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.delay_fix(bl, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_delay_fix_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_delay_fix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_delay_fix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_check_condition_castbegin(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_condition_castbegin(sd, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_check_condition_castbegin_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_check_condition_castend(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_condition_castend(sd, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_check_condition_castend_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_condition_castend_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_consume_requirement(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, short type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.consume_requirement(sd, skill_id, skill_lv, type);
	}
	if( HPMHooks.count.HP_skill_consume_requirement_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv, short type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_consume_requirement_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_consume_requirement_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv, type);
		}
	}
	return retVal___;
}
struct skill_condition HP_skill_get_requirement(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	struct skill_condition retVal___ = { 0 };
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_requirement(sd, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_requirement_post ) {
		struct skill_condition (*postHookFunc) (struct skill_condition retVal___, struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_requirement_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_check_pc_partner(struct map_session_data *sd, uint16 skill_id, uint16 *skill_lv, int range, int cast_flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_pc_partner(sd, skill_id, skill_lv, range, cast_flag);
	}
	if( HPMHooks.count.HP_skill_check_pc_partner_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, uint16 *skill_lv, int range, int cast_flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_pc_partner_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_pc_partner_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, skill_lv, range, cast_flag);
		}
	}
	return retVal___;
}
int HP_skill_unit_move(struct block_list *bl, int64 tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unit_move(bl, tick, flag);
	}
	if( HPMHooks.count.HP_skill_unit_move_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_move_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, tick, flag);
		}
	}
	return retVal___;
}
int HP_skill_unit_onleft(uint16 skill_id, struct block_list *bl, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unit_onleft(skill_id, bl, tick);
	}
	if( HPMHooks.count.HP_skill_unit_onleft_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, struct block_list *bl, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onleft_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_onleft_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, bl, tick);
		}
	}
	return retVal___;
}
int HP_skill_unit_onout(struct skill_unit *src, struct block_list *bl, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unit_onout(src, bl, tick);
	}
	if( HPMHooks.count.HP_skill_unit_onout_post ) {
		int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onout_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_onout_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, tick);
		}
	}
	return retVal___;
}
int HP_skill_unit_move_unit_group(struct skill_unit_group *group, int16 m, int16 dx, int16 dy) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unit_move_unit_group(group, m, dx, dy);
	}
	if( HPMHooks.count.HP_skill_unit_move_unit_group_post ) {
		int (*postHookFunc) (int retVal___, struct skill_unit_group *group, int16 m, int16 dx, int16 dy);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_unit_group_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_move_unit_group_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, group, m, dx, dy);
		}
	}
	return retVal___;
}
int HP_skill_sit(struct map_session_data *sd, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.sit(sd, type);
	}
	if( HPMHooks.count.HP_skill_sit_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_sit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, type);
		}
	}
	return retVal___;
}
void HP_skill_brandishspear(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_brandishspear_pre ) {
		void (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 *skill_id, uint16 *skill_lv, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.brandishspear(src, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_brandishspear_post ) {
		void (*postHookFunc) (struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_brandishspear_post[hIndex].func;
			postHookFunc(src, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return;
}
void HP_skill_repairweapon(struct map_session_data *sd, int idx) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_repairweapon_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *idx);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.repairweapon(sd, idx);
	}
	if( HPMHooks.count.HP_skill_repairweapon_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_repairweapon_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_repairweapon_post[hIndex].func;
			postHookFunc(sd, idx);
		}
	}
	return;
}
void HP_skill_identify(struct map_session_data *sd, int idx) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_identify_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *idx);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.identify(sd, idx);
	}
	if( HPMHooks.count.HP_skill_identify_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_identify_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_identify_post[hIndex].func;
			postHookFunc(sd, idx);
		}
	}
	return;
}
void HP_skill_weaponrefine(struct map_session_data *sd, int idx) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_weaponrefine_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *idx);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.weaponrefine(sd, idx);
	}
	if( HPMHooks.count.HP_skill_weaponrefine_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_weaponrefine_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_weaponrefine_post[hIndex].func;
			postHookFunc(sd, idx);
		}
	}
	return;
}
int HP_skill_autospell(struct map_session_data *md, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.autospell(md, skill_id);
	}
	if( HPMHooks.count.HP_skill_autospell_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *md, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_autospell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_autospell_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_calc_heal(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, bool heal) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.calc_heal(src, target, skill_id, skill_lv, heal);
	}
	if( HPMHooks.count.HP_skill_calc_heal_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, bool heal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_calc_heal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_calc_heal_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, heal);
		}
	}
	return retVal___;
}
bool HP_skill_check_cloaking(struct block_list *bl, struct status_change_entry *sce) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_cloaking(bl, sce);
	}
	if( HPMHooks.count.HP_skill_check_cloaking_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct status_change_entry *sce);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_cloaking_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_cloaking_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sce);
		}
	}
	return retVal___;
}
int HP_skill_check_cloaking_end(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_check_cloaking_end_pre ) {
		int (*preHookFunc) (struct block_list **bl, va_list ap);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_cloaking_end_pre; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			preHookFunc = HPMHooks.list.HP_skill_check_cloaking_end_pre[hIndex].func;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.check_cloaking_end(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_check_cloaking_end_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_cloaking_end_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_check_cloaking_end_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
bool HP_skill_can_cloak(struct map_session_data *sd) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_can_cloak_pre ) {
		bool (*preHookFunc) (struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_can_cloak_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_can_cloak_pre[hIndex].func;
			retVal___ = preHookFunc(&sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.can_cloak(sd);
	}
	if( HPMHooks.count.HP_skill_can_cloak_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_can_cloak_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_can_cloak_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_skill_enchant_elemental_end(struct block_list *bl, int type) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.enchant_elemental_end(bl, type);
	}
	if( HPMHooks.count.HP_skill_enchant_elemental_end_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_enchant_elemental_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_enchant_elemental_end_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, type);
		}
	}
	return retVal___;
}
int HP_skill_not_ok(uint16 skill_id, struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.not_ok(skill_id, sd);
	}
	if( HPMHooks.count.HP_skill_not_ok_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_not_ok_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, sd);
		}
	}
	return retVal___;
}
int HP_skill_not_ok_unknown(uint16 skill_id, struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_not_ok_unknown_pre ) {
		int (*preHookFunc) (uint16 *skill_id, struct map_session_data **sd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_not_ok_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&skill_id, &sd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.not_ok_unknown(skill_id, sd);
	}
	if( HPMHooks.count.HP_skill_not_ok_unknown_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_not_ok_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, sd);
		}
	}
	return retVal___;
}
int HP_skill_not_ok_hom(uint16 skill_id, struct homun_data *hd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.not_ok_hom(skill_id, hd);
	}
	if( HPMHooks.count.HP_skill_not_ok_hom_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_hom_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_not_ok_hom_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, hd);
		}
	}
	return retVal___;
}
int HP_skill_not_ok_hom_unknown(uint16 skill_id, struct homun_data *hd) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_not_ok_hom_unknown_pre ) {
		int (*preHookFunc) (uint16 *skill_id, struct homun_data **hd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_hom_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_not_ok_hom_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&skill_id, &hd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.not_ok_hom_unknown(skill_id, hd);
	}
	if( HPMHooks.count.HP_skill_not_ok_hom_unknown_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, struct homun_data *hd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_hom_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_not_ok_hom_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, hd);
		}
	}
	return retVal___;
}
int HP_skill_not_ok_mercenary(uint16 skill_id, struct mercenary_data *md) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.not_ok_mercenary(skill_id, md);
	}
	if( HPMHooks.count.HP_skill_not_ok_mercenary_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, struct mercenary_data *md);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_not_ok_mercenary_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_not_ok_mercenary_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, md);
		}
	}
	return retVal___;
}
int HP_skill_chastle_mob_changetarget(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.chastle_mob_changetarget(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_chastle_mob_changetarget_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_chastle_mob_changetarget_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_chastle_mob_changetarget_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_can_produce_mix(struct map_session_data *sd, int nameid, int trigger, int qty) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.can_produce_mix(sd, nameid, trigger, qty);
	}
	if( HPMHooks.count.HP_skill_can_produce_mix_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid, int trigger, int qty);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_can_produce_mix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_can_produce_mix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid, trigger, qty);
		}
	}
	return retVal___;
}
int HP_skill_produce_mix(struct map_session_data *sd, uint16 skill_id, int nameid, int slot1, int slot2, int slot3, int qty) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.produce_mix(sd, skill_id, nameid, slot1, slot2, slot3, qty);
	}
	if( HPMHooks.count.HP_skill_produce_mix_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, int nameid, int slot1, int slot2, int slot3, int qty);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_produce_mix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_produce_mix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, nameid, slot1, slot2, slot3, qty);
		}
	}
	return retVal___;
}
int HP_skill_arrow_create(struct map_session_data *sd, int nameid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.arrow_create(sd, nameid);
	}
	if( HPMHooks.count.HP_skill_arrow_create_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_arrow_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_arrow_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid);
		}
	}
	return retVal___;
}
void HP_skill_castend_type(int type, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_castend_type_pre ) {
		void (*preHookFunc) (int *type, 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_type_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_type_pre[hIndex].func;
			preHookFunc(&type, &src, &bl, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.castend_type(type, src, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_type_post ) {
		void (*postHookFunc) (int type, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_type_post[hIndex].func;
			postHookFunc(type, src, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return;
}
int HP_skill_castend_nodamage_id(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_nodamage_id(src, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_nodamage_id_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
int HP_skill_castend_damage_id(struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_damage_id(src, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_damage_id_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_damage_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
int HP_skill_castend_pos2(struct block_list *src, int x, int y, uint16 skill_id, uint16 skill_lv, int64 tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_pos2(src, x, y, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_pos2_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, int x, int y, uint16 skill_id, uint16 skill_lv, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_pos2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, x, y, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
int HP_skill_blockpc_start(struct map_session_data *sd, uint16 skill_id, int tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.blockpc_start(sd, skill_id, tick);
	}
	if( HPMHooks.count.HP_skill_blockpc_start_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id, int tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_blockpc_start_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id, tick);
		}
	}
	return retVal___;
}
int HP_skill_blockhomun_start(struct homun_data *hd, uint16 skill_id, int tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.blockhomun_start(hd, skill_id, tick);
	}
	if( HPMHooks.count.HP_skill_blockhomun_start_post ) {
		int (*postHookFunc) (int retVal___, struct homun_data *hd, uint16 skill_id, int tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_blockhomun_start_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, skill_id, tick);
		}
	}
	return retVal___;
}
int HP_skill_blockmerc_start(struct mercenary_data *md, uint16 skill_id, int tick) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.blockmerc_start(md, skill_id, tick);
	}
	if( HPMHooks.count.HP_skill_blockmerc_start_post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md, uint16 skill_id, int tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_blockmerc_start_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, skill_id, tick);
		}
	}
	return retVal___;
}
int HP_skill_attack(int attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.attack(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_attack_post ) {
		int (*postHookFunc) (int retVal___, int attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 skill_id, uint16 skill_lv, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_attack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
int HP_skill_attack_area(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.attack_area(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_attack_area_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_area_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_attack_area_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_area_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.area_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_area_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_area_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_area_sub_count(struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.area_sub_count(src, target, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_area_sub_count_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, uint16 skill_lv, int64 tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_area_sub_count_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_area_sub_count_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
int HP_skill_check_unit_range(struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_unit_range(bl, x, y, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_check_unit_range_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_unit_range_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, x, y, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_check_unit_range_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.check_unit_range_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_check_unit_range_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_check_unit_range_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_check_unit_range2(struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_unit_range2(bl, x, y, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_check_unit_range2_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int x, int y, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_unit_range2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, x, y, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_check_unit_range2_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.check_unit_range2_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_check_unit_range2_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_unit_range2_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_check_unit_range2_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_skill_toggle_magicpower(struct block_list *bl, uint16 skill_id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_toggle_magicpower_pre ) {
		void (*preHookFunc) (struct block_list **bl, uint16 *skill_id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.toggle_magicpower(bl, skill_id);
	}
	if( HPMHooks.count.HP_skill_toggle_magicpower_post ) {
		void (*postHookFunc) (struct block_list *bl, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_toggle_magicpower_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_toggle_magicpower_post[hIndex].func;
			postHookFunc(bl, skill_id);
		}
	}
	return;
}
int HP_skill_magic_reflect(struct block_list *src, struct block_list *bl, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.magic_reflect(src, bl, type);
	}
	if( HPMHooks.count.HP_skill_magic_reflect_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magic_reflect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_magic_reflect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, type);
		}
	}
	return retVal___;
}
int HP_skill_onskillusage(struct map_session_data *sd, struct block_list *bl, uint16 skill_id, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.onskillusage(sd, bl, skill_id, tick);
	}
	if( HPMHooks.count.HP_skill_onskillusage_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct block_list *bl, uint16 skill_id, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_onskillusage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_onskillusage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, bl, skill_id, tick);
		}
	}
	return retVal___;
}
int HP_skill_cell_overlap(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.cell_overlap(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_cell_overlap_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cell_overlap_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_cell_overlap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_timerskill(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.timerskill(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_skill_timerskill_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_timerskill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_skill_trap_splash(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.trap_splash(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_trap_splash_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_trap_splash_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_trap_splash_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_check_condition_mercenary(struct block_list *bl, int skill_id, int lv, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_condition_mercenary(bl, skill_id, lv, type);
	}
	if( HPMHooks.count.HP_skill_check_condition_mercenary_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int skill_id, int lv, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mercenary_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_condition_mercenary_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, skill_id, lv, type);
		}
	}
	return retVal___;
}
struct skill_unit_group* HP_skill_locate_element_field(struct block_list *bl) {
	int hIndex = 0;
	struct skill_unit_group* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_locate_element_field_pre ) {
		struct skill_unit_group* (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.locate_element_field(bl);
	}
	if( HPMHooks.count.HP_skill_locate_element_field_post ) {
		struct skill_unit_group* (*postHookFunc) (struct skill_unit_group* retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_locate_element_field_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_locate_element_field_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_skill_graffitiremover(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.graffitiremover(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_graffitiremover_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_graffitiremover_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_graffitiremover_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_activate_reverberation(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.activate_reverberation(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_activate_reverberation_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_activate_reverberation_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_activate_reverberation_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_dance_overlap_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.dance_overlap_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_dance_overlap_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_dance_overlap_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_dance_overlap(struct skill_unit *su, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.dance_overlap(su, flag);
	}
	if( HPMHooks.count.HP_skill_dance_overlap_post ) {
		int (*postHookFunc) (int retVal___, struct skill_unit *su, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_overlap_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_dance_overlap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, su, flag);
		}
	}
	return retVal___;
}
struct s_skill_unit_layout* HP_skill_get_unit_layout(uint16 skill_id, uint16 skill_lv, struct block_list *src, int x, int y) {
	int hIndex = 0;
	struct s_skill_unit_layout* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_get_unit_layout_pre ) {
		struct s_skill_unit_layout* (*preHookFunc) (uint16 *skill_id, uint16 *skill_lv, struct block_list **src, int *x, int *y);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_unit_layout(skill_id, skill_lv, src, x, y);
	}
	if( HPMHooks.count.HP_skill_get_unit_layout_post ) {
		struct s_skill_unit_layout* (*postHookFunc) (struct s_skill_unit_layout* retVal___, uint16 skill_id, uint16 skill_lv, struct block_list *src, int x, int y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_unit_layout_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_unit_layout_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv, src, x, y);
		}
	}
	return retVal___;
}
int HP_skill_frostjoke_scream(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.frostjoke_scream(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_frostjoke_scream_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_frostjoke_scream_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_frostjoke_scream_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_greed(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.greed(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_greed_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_greed_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_greed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_destroy_trap(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.destroy_trap(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_destroy_trap_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_destroy_trap_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_destroy_trap_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
struct skill_unit_group_tickset* HP_skill_unitgrouptickset_search(struct block_list *bl, struct skill_unit_group *group, int64 tick) {
	int hIndex = 0;
	struct skill_unit_group_tickset* retVal___ = NULL;
	if( HPMHooks.count.HP_skill_unitgrouptickset_search_pre ) {
		struct skill_unit_group_tickset* (*preHookFunc) (struct block_list **bl, struct skill_unit_group **group, 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unitgrouptickset_search(bl, group, tick);
	}
	if( HPMHooks.count.HP_skill_unitgrouptickset_search_post ) {
		struct skill_unit_group_tickset* (*postHookFunc) (struct skill_unit_group_tickset* retVal___, struct block_list *bl, struct skill_unit_group *group, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitgrouptickset_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unitgrouptickset_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, group, tick);
		}
	}
	return retVal___;
}
bool HP_skill_dance_switch(struct skill_unit *su, int flag) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.dance_switch(su, flag);
	}
	if( HPMHooks.count.HP_skill_dance_switch_post ) {
		bool (*postHookFunc) (bool retVal___, struct skill_unit *su, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_dance_switch_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_dance_switch_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, su, flag);
		}
	}
	return retVal___;
}
int HP_skill_check_condition_char_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.check_condition_char_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_check_condition_char_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_char_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_check_condition_char_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_check_condition_mob_master_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.check_condition_mob_master_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_check_condition_mob_master_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_mob_master_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_check_condition_mob_master_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_skill_brandishspear_first(struct square *tc, uint8 dir, int16 x, int16 y) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_brandishspear_first_pre ) {
		void (*preHookFunc) (struct square **tc, uint8 *dir, int16 *x, int16 *y);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.brandishspear_first(tc, dir, x, y);
	}
	if( HPMHooks.count.HP_skill_brandishspear_first_post ) {
		void (*postHookFunc) (struct square *tc, uint8 dir, int16 x, int16 y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_first_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_brandishspear_first_post[hIndex].func;
			postHookFunc(tc, dir, x, y);
		}
	}
	return;
}
void HP_skill_brandishspear_dir(struct square *tc, uint8 dir, int are) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_brandishspear_dir_pre ) {
		void (*preHookFunc) (struct square **tc, uint8 *dir, int *are);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.brandishspear_dir(tc, dir, are);
	}
	if( HPMHooks.count.HP_skill_brandishspear_dir_post ) {
		void (*postHookFunc) (struct square *tc, uint8 dir, int are);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_brandishspear_dir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_brandishspear_dir_post[hIndex].func;
			postHookFunc(tc, dir, are);
		}
	}
	return;
}
int HP_skill_get_fixed_cast(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_fixed_cast(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_fixed_cast_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_fixed_cast_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_fixed_cast_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_skill_sit_count(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.sit_count(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_sit_count_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_count_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_sit_count_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_sit_in(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.sit_in(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_sit_in_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_in_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_sit_in_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_sit_out(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.sit_out(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_sit_out_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_sit_out_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_sit_out_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_skill_unitsetmapcell(struct skill_unit *src, uint16 skill_id, uint16 skill_lv, cell_t cell, bool flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_unitsetmapcell_pre ) {
		void (*preHookFunc) (struct skill_unit **src, uint16 *skill_id, uint16 *skill_lv, cell_t *cell, bool *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.unitsetmapcell(src, skill_id, skill_lv, cell, flag);
	}
	if( HPMHooks.count.HP_skill_unitsetmapcell_post ) {
		void (*postHookFunc) (struct skill_unit *src, uint16 skill_id, uint16 skill_lv, cell_t cell, bool flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetmapcell_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unitsetmapcell_post[hIndex].func;
			postHookFunc(src, skill_id, skill_lv, cell, flag);
		}
	}
	return;
}
int HP_skill_unit_onplace_timer(struct skill_unit *src, struct block_list *bl, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unit_onplace_timer(src, bl, tick);
	}
	if( HPMHooks.count.HP_skill_unit_onplace_timer_post ) {
		int (*postHookFunc) (int retVal___, struct skill_unit *src, struct block_list *bl, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_onplace_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, tick);
		}
	}
	return retVal___;
}
void HP_skill_unit_onplace_timer_unknown(struct skill_unit *src, struct block_list *bl, int64 *tick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_unit_onplace_timer_unknown_pre ) {
		void (*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_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_unit_onplace_timer_unknown_pre[hIndex].func;
			preHookFunc(&src, &bl, &tick);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.unit_onplace_timer_unknown(src, bl, tick);
	}
	if( HPMHooks.count.HP_skill_unit_onplace_timer_unknown_post ) {
		void (*postHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_timer_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_onplace_timer_unknown_post[hIndex].func;
			postHookFunc(src, bl, tick);
		}
	}
	return;
}
int HP_skill_unit_effect(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.unit_effect(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_unit_effect_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_effect_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_unit_effect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_unit_timer_sub_onplace(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.unit_timer_sub_onplace(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_unit_timer_sub_onplace_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_onplace_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_onplace_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_unit_move_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.unit_move_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_unit_move_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_move_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_unit_move_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_skill_blockpc_end(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.blockpc_end(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_skill_blockpc_end_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockpc_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_blockpc_end_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_skill_blockhomun_end(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.blockhomun_end(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_skill_blockhomun_end_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockhomun_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_blockhomun_end_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_skill_blockmerc_end(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.blockmerc_end(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_skill_blockmerc_end_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_blockmerc_end_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_blockmerc_end_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_skill_split_atoi(char *str, int *val) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.split_atoi(str, val);
	}
	if( HPMHooks.count.HP_skill_split_atoi_post ) {
		int (*postHookFunc) (int retVal___, char *str, int *val);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_split_atoi_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_split_atoi_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, val);
		}
	}
	return retVal___;
}
int HP_skill_unit_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.unit_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_skill_unit_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_skill_unit_timer_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_unit_timer_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.unit_timer_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_unit_timer_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_timer_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_unit_timer_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
void HP_skill_init_unit_layout(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_init_unit_layout_pre ) {
		void (*preHookFunc) (void);
		*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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.init_unit_layout();
	}
	if( HPMHooks.count.HP_skill_init_unit_layout_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unit_layout_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_init_unit_layout_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_skill_init_unit_layout_unknown(int skill_idx) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_init_unit_layout_unknown_pre ) {
		void (*preHookFunc) (int *skill_idx);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unit_layout_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_init_unit_layout_unknown_pre[hIndex].func;
			preHookFunc(&skill_idx);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.init_unit_layout_unknown(skill_idx);
	}
	if( HPMHooks.count.HP_skill_init_unit_layout_unknown_post ) {
		void (*postHookFunc) (int skill_idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_init_unit_layout_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_init_unit_layout_unknown_post[hIndex].func;
			postHookFunc(skill_idx);
		}
	}
	return;
}
void HP_skill_validate_hittype(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_hittype_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_hittype_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_hittype_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_hittype(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_hittype_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_hittype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_hittype_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_skilltype(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_skilltype_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_skilltype_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_skilltype_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_skilltype(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_skilltype_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_skilltype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_skilltype_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_attacktype(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_attacktype_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_attacktype_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_attacktype_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_attacktype(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_attacktype_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_attacktype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_attacktype_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_element(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_element_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_element_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_element_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_element(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_element_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_element_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_element_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_skillinfo(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_skillinfo_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_skillinfo_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_skillinfo_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_skillinfo(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_skillinfo_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_skillinfo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_skillinfo_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_damagetype(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_damagetype_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_damagetype_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_damagetype_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_damagetype(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_damagetype_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_damagetype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_damagetype_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_castnodex(struct config_setting_t *conf, struct s_skill_db *sk, bool delay) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_castnodex_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk, bool *delay);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_castnodex_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_castnodex_pre[hIndex].func;
			preHookFunc(&conf, &sk, &delay);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_castnodex(conf, sk, delay);
	}
	if( HPMHooks.count.HP_skill_validate_castnodex_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk, bool delay);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_castnodex_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_castnodex_post[hIndex].func;
			postHookFunc(conf, sk, delay);
		}
	}
	return;
}
void HP_skill_validate_weapontype(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_weapontype_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_weapontype_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_weapontype_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_weapontype(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_weapontype_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_weapontype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_weapontype_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_ammotype(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_ammotype_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_ammotype_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_ammotype_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_ammotype(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_ammotype_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_ammotype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_ammotype_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_state(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_state_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_state_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_state_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_state(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_state_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_state_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_state_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_item_requirements(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_item_requirements_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_item_requirements_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_item_requirements_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_item_requirements(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_item_requirements_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_item_requirements_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_item_requirements_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_unit_target(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_unit_target_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_unit_target_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_unit_target_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_unit_target(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_unit_target_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_unit_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_unit_target_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_unit_flag(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_unit_flag_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_unit_flag_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_unit_flag_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_unit_flag(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_unit_flag_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_unit_flag_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_unit_flag_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
void HP_skill_validate_additional_fields(struct config_setting_t *conf, struct s_skill_db *sk) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_validate_additional_fields_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, struct s_skill_db **sk);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_additional_fields_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_additional_fields_pre[hIndex].func;
			preHookFunc(&conf, &sk);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.validate_additional_fields(conf, sk);
	}
	if( HPMHooks.count.HP_skill_validate_additional_fields_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, struct s_skill_db *sk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_additional_fields_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_additional_fields_post[hIndex].func;
			postHookFunc(conf, sk);
		}
	}
	return;
}
bool HP_skill_validate_skilldb(struct s_skill_db *skt, const char *source) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_validate_skilldb_pre ) {
		bool (*preHookFunc) (struct s_skill_db **skt, const char **source);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_skilldb_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_validate_skilldb_pre[hIndex].func;
			retVal___ = preHookFunc(&skt, &source);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.validate_skilldb(skt, source);
	}
	if( HPMHooks.count.HP_skill_validate_skilldb_post ) {
		bool (*postHookFunc) (bool retVal___, struct s_skill_db *skt, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_validate_skilldb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_validate_skilldb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skt, source);
		}
	}
	return retVal___;
}
bool HP_skill_read_skilldb(const char *filename) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_read_skilldb_pre ) {
		bool (*preHookFunc) (const char **filename);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_read_skilldb_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_read_skilldb_pre[hIndex].func;
			retVal___ = preHookFunc(&filename);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.read_skilldb(filename);
	}
	if( HPMHooks.count.HP_skill_read_skilldb_post ) {
		bool (*postHookFunc) (bool retVal___, const char *filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_read_skilldb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_read_skilldb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename);
		}
	}
	return retVal___;
}
void HP_skill_config_set_level(struct config_setting_t *conf, int *arr) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_config_set_level_pre ) {
		void (*preHookFunc) (struct config_setting_t **conf, int **arr);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_config_set_level_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_config_set_level_pre[hIndex].func;
			preHookFunc(&conf, &arr);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.config_set_level(conf, arr);
	}
	if( HPMHooks.count.HP_skill_config_set_level_post ) {
		void (*postHookFunc) (struct config_setting_t *conf, int *arr);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_config_set_level_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_config_set_level_post[hIndex].func;
			postHookFunc(conf, arr);
		}
	}
	return;
}
void HP_skill_level_set_value(int *arr, int value) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_level_set_value_pre ) {
		void (*preHookFunc) (int **arr, int *value);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_level_set_value_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_level_set_value_pre[hIndex].func;
			preHookFunc(&arr, &value);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.level_set_value(arr, value);
	}
	if( HPMHooks.count.HP_skill_level_set_value_post ) {
		void (*postHookFunc) (int *arr, int value);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_level_set_value_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_level_set_value_post[hIndex].func;
			postHookFunc(arr, value);
		}
	}
	return;
}
bool HP_skill_parse_row_producedb(char *split[], int columns, int current) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.parse_row_producedb(split, columns, current);
	}
	if( HPMHooks.count.HP_skill_parse_row_producedb_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_producedb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_parse_row_producedb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, columns, current);
		}
	}
	return retVal___;
}
bool HP_skill_parse_row_createarrowdb(char *split[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.parse_row_createarrowdb(split, columns, current);
	}
	if( HPMHooks.count.HP_skill_parse_row_createarrowdb_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_createarrowdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_parse_row_createarrowdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, columns, current);
		}
	}
	return retVal___;
}
bool HP_skill_parse_row_abradb(char *split[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.parse_row_abradb(split, columns, current);
	}
	if( HPMHooks.count.HP_skill_parse_row_abradb_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_abradb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_parse_row_abradb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, columns, current);
		}
	}
	return retVal___;
}
bool HP_skill_parse_row_spellbookdb(char *split[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.parse_row_spellbookdb(split, columns, current);
	}
	if( HPMHooks.count.HP_skill_parse_row_spellbookdb_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_spellbookdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_parse_row_spellbookdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, columns, current);
		}
	}
	return retVal___;
}
bool HP_skill_parse_row_magicmushroomdb(char *split[], int column, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.parse_row_magicmushroomdb(split, column, current);
	}
	if( HPMHooks.count.HP_skill_parse_row_magicmushroomdb_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int column, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_magicmushroomdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_parse_row_magicmushroomdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, column, current);
		}
	}
	return retVal___;
}
bool HP_skill_parse_row_reproducedb(char *split[], int column, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.parse_row_reproducedb(split, column, current);
	}
	if( HPMHooks.count.HP_skill_parse_row_reproducedb_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int column, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_reproducedb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_parse_row_reproducedb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, column, current);
		}
	}
	return retVal___;
}
bool HP_skill_parse_row_improvisedb(char *split[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.parse_row_improvisedb(split, columns, current);
	}
	if( HPMHooks.count.HP_skill_parse_row_improvisedb_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_improvisedb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_parse_row_improvisedb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, columns, current);
		}
	}
	return retVal___;
}
bool HP_skill_parse_row_changematerialdb(char *split[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.parse_row_changematerialdb(split, columns, current);
	}
	if( HPMHooks.count.HP_skill_parse_row_changematerialdb_post ) {
		bool (*postHookFunc) (bool retVal___, char *split[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_parse_row_changematerialdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_parse_row_changematerialdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, split, columns, current);
		}
	}
	return retVal___;
}
void HP_skill_usave_add(struct map_session_data *sd, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_usave_add_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, uint16 *skill_id, uint16 *skill_lv);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.usave_add(sd, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_usave_add_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_usave_add_post[hIndex].func;
			postHookFunc(sd, skill_id, skill_lv);
		}
	}
	return;
}
void HP_skill_usave_trigger(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_usave_trigger_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.usave_trigger(sd);
	}
	if( HPMHooks.count.HP_skill_usave_trigger_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_usave_trigger_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_usave_trigger_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_skill_cooldown_load(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_cooldown_load_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.cooldown_load(sd);
	}
	if( HPMHooks.count.HP_skill_cooldown_load_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_load_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_cooldown_load_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_skill_spellbook(struct map_session_data *sd, int nameid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.spellbook(sd, nameid);
	}
	if( HPMHooks.count.HP_skill_spellbook_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_spellbook_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_spellbook_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid);
		}
	}
	return retVal___;
}
int HP_skill_block_check(struct block_list *bl, enum sc_type type, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.block_check(bl, type, skill_id);
	}
	if( HPMHooks.count.HP_skill_block_check_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type type, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_block_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_block_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, type, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_detonator(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.detonator(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_detonator_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_detonator_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_detonator_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
bool HP_skill_check_camouflage(struct block_list *bl, struct status_change_entry *sce) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_camouflage(bl, sce);
	}
	if( HPMHooks.count.HP_skill_check_camouflage_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct status_change_entry *sce);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_camouflage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_camouflage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sce);
		}
	}
	return retVal___;
}
int HP_skill_magicdecoy(struct map_session_data *sd, int nameid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.magicdecoy(sd, nameid);
	}
	if( HPMHooks.count.HP_skill_magicdecoy_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_magicdecoy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_magicdecoy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid);
		}
	}
	return retVal___;
}
int HP_skill_poisoningweapon(struct map_session_data *sd, int nameid) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.poisoningweapon(sd, nameid);
	}
	if( HPMHooks.count.HP_skill_poisoningweapon_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_poisoningweapon_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_poisoningweapon_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid);
		}
	}
	return retVal___;
}
int HP_skill_select_menu(struct map_session_data *sd, uint16 skill_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.select_menu(sd, skill_id);
	}
	if( HPMHooks.count.HP_skill_select_menu_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_select_menu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_select_menu_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_elementalanalysis(struct map_session_data *sd, uint16 skill_lv, const struct itemlist *item_list) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_elementalanalysis_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, uint16 *skill_lv, const struct itemlist **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, &skill_lv, &item_list);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.elementalanalysis(sd, skill_lv, item_list);
	}
	if( HPMHooks.count.HP_skill_elementalanalysis_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, uint16 skill_lv, const struct itemlist *item_list);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_elementalanalysis_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_elementalanalysis_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, skill_lv, item_list);
		}
	}
	return retVal___;
}
int HP_skill_changematerial(struct map_session_data *sd, const struct itemlist *item_list) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_changematerial_pre ) {
		int (*preHookFunc) (struct map_session_data **sd, const struct itemlist **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, &item_list);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.changematerial(sd, item_list);
	}
	if( HPMHooks.count.HP_skill_changematerial_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, const struct itemlist *item_list);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_changematerial_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_changematerial_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_list);
		}
	}
	return retVal___;
}
int HP_skill_get_elemental_type(uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_elemental_type(skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_get_elemental_type_post ) {
		int (*postHookFunc) (int retVal___, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_elemental_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_elemental_type_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id, skill_lv);
		}
	}
	return retVal___;
}
void HP_skill_cooldown_save(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_cooldown_save_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.cooldown_save(sd);
	}
	if( HPMHooks.count.HP_skill_cooldown_save_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cooldown_save_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_cooldown_save_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_skill_get_new_group_id(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_new_group_id();
	}
	if( HPMHooks.count.HP_skill_get_new_group_id_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_new_group_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_new_group_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_skill_check_shadowform(struct block_list *bl, int64 damage, int hit) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_shadowform(bl, damage, hit);
	}
	if( HPMHooks.count.HP_skill_check_shadowform_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl, int64 damage, int hit);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_shadowform_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_shadowform_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, damage, hit);
		}
	}
	return retVal___;
}
bool HP_skill_castend_damage_id_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_castend_damage_id_unknown_pre ) {
		bool (*preHookFunc) (struct block_list **src, struct block_list **bl, uint16 **skill_id, uint16 **skill_lv, int64 **tick, int **flag, struct status_data **tstatus, struct status_change **sc);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_damage_id_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag, &tstatus, &sc);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_damage_id_unknown(src, bl, skill_id, skill_lv, tick, flag, tstatus, sc);
	}
	if( HPMHooks.count.HP_skill_castend_damage_id_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag, struct status_data *tstatus, struct status_change *sc);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_damage_id_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_damage_id_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag, tstatus, sc);
		}
	}
	return retVal___;
}
void HP_skill_additional_effect_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_additional_effect_unknown_pre ) {
		void (*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_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_additional_effect_unknown_pre[hIndex].func;
			preHookFunc(&src, &bl, &skill_id, &skill_lv, &attack_type, &dmg_lv, &tick);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.additional_effect_unknown(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick);
	}
	if( HPMHooks.count.HP_skill_additional_effect_unknown_post ) {
		void (*postHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int *dmg_lv, int64 *tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_additional_effect_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_additional_effect_unknown_post[hIndex].func;
			postHookFunc(src, bl, skill_id, skill_lv, attack_type, dmg_lv, tick);
		}
	}
	return;
}
void HP_skill_counter_additional_effect_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_counter_additional_effect_unknown_pre ) {
		void (*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_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_unknown_pre[hIndex].func;
			preHookFunc(&src, &bl, &skill_id, &skill_lv, &attack_type, &tick);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.counter_additional_effect_unknown(src, bl, skill_id, skill_lv, attack_type, tick);
	}
	if( HPMHooks.count.HP_skill_counter_additional_effect_unknown_post ) {
		void (*postHookFunc) (struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int *attack_type, int64 *tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_counter_additional_effect_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_counter_additional_effect_unknown_post[hIndex].func;
			postHookFunc(src, bl, skill_id, skill_lv, attack_type, tick);
		}
	}
	return;
}
void HP_skill_attack_combo1_unknown(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, struct status_change_entry *sce, int *combo) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_attack_combo1_unknown_pre ) {
		void (*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, struct status_change_entry **sce, int **combo);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo1_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_attack_combo1_unknown_pre[hIndex].func;
			preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag, &sce, &combo);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.attack_combo1_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, sce, combo);
	}
	if( HPMHooks.count.HP_skill_attack_combo1_unknown_post ) {
		void (*postHookFunc) (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, struct status_change_entry *sce, int *combo);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo1_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_attack_combo1_unknown_post[hIndex].func;
			postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, sce, combo);
		}
	}
	return;
}
void HP_skill_attack_combo2_unknown(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, int *combo) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_attack_combo2_unknown_pre ) {
		void (*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, int **combo);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo2_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_attack_combo2_unknown_pre[hIndex].func;
			preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag, &combo);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.attack_combo2_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, combo);
	}
	if( HPMHooks.count.HP_skill_attack_combo2_unknown_post ) {
		void (*postHookFunc) (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, int *combo);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_combo2_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_attack_combo2_unknown_post[hIndex].func;
			postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, combo);
		}
	}
	return;
}
void HP_skill_attack_display_unknown(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, int *type, struct Damage *dmg, int64 *damage) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_attack_display_unknown_pre ) {
		void (*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, int **type, struct Damage **dmg, int64 **damage);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_display_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_attack_display_unknown_pre[hIndex].func;
			preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag, &type, &dmg, &damage);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.attack_display_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage);
	}
	if( HPMHooks.count.HP_skill_attack_display_unknown_post ) {
		void (*postHookFunc) (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, int *type, struct Damage *dmg, int64 *damage);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_display_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_attack_display_unknown_post[hIndex].func;
			postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage);
		}
	}
	return;
}
int HP_skill_attack_copy_unknown(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) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_attack_copy_unknown_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_copy_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_attack_copy_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.attack_copy_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_attack_copy_unknown_post ) {
		int (*postHookFunc) (int retVal___, int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_copy_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_attack_copy_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
int HP_skill_attack_dir_unknown(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) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_attack_dir_unknown_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_dir_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_attack_dir_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.attack_dir_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_attack_dir_unknown_post ) {
		int (*postHookFunc) (int retVal___, int *attack_type, struct block_list *src, struct block_list *dsrc, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_dir_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_attack_dir_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
void HP_skill_attack_blow_unknown(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, int *type, struct Damage *dmg, int64 *damage, int8 *dir) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_attack_blow_unknown_pre ) {
		void (*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, int **type, struct Damage **dmg, int64 **damage, int8 **dir);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_blow_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_attack_blow_unknown_pre[hIndex].func;
			preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag, &type, &dmg, &damage, &dir);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.attack_blow_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage, dir);
	}
	if( HPMHooks.count.HP_skill_attack_blow_unknown_post ) {
		void (*postHookFunc) (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, int *type, struct Damage *dmg, int64 *damage, int8 *dir);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_blow_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_attack_blow_unknown_post[hIndex].func;
			postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag, type, dmg, damage, dir);
		}
	}
	return;
}
void HP_skill_attack_post_unknown(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) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_attack_post_unknown_pre ) {
		void (*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_post_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_attack_post_unknown_pre[hIndex].func;
			preHookFunc(&attack_type, &src, &dsrc, &bl, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.attack_post_unknown(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_attack_post_unknown_post ) {
		void (*postHookFunc) (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);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_attack_post_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_attack_post_unknown_post[hIndex].func;
			postHookFunc(attack_type, src, dsrc, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return;
}
bool HP_skill_timerskill_dead_unknown(struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_timerskill_dead_unknown_pre ) {
		bool (*preHookFunc) (struct block_list **src, struct unit_data **ud, struct skill_timerskill **skl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_dead_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_timerskill_dead_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &ud, &skl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.timerskill_dead_unknown(src, ud, skl);
	}
	if( HPMHooks.count.HP_skill_timerskill_dead_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_dead_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_timerskill_dead_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, ud, skl);
		}
	}
	return retVal___;
}
void HP_skill_timerskill_target_unknown(int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_timerskill_target_unknown_pre ) {
		void (*preHookFunc) (int *tid, int64 *tick, struct block_list **src, struct block_list **target, struct unit_data **ud, struct skill_timerskill **skl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_target_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_timerskill_target_unknown_pre[hIndex].func;
			preHookFunc(&tid, &tick, &src, &target, &ud, &skl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.timerskill_target_unknown(tid, tick, src, target, ud, skl);
	}
	if( HPMHooks.count.HP_skill_timerskill_target_unknown_post ) {
		void (*postHookFunc) (int tid, int64 tick, struct block_list *src, struct block_list *target, struct unit_data *ud, struct skill_timerskill *skl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_target_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_timerskill_target_unknown_post[hIndex].func;
			postHookFunc(tid, tick, src, target, ud, skl);
		}
	}
	return;
}
void HP_skill_timerskill_notarget_unknown(int tid, int64 tick, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_timerskill_notarget_unknown_pre ) {
		void (*preHookFunc) (int *tid, int64 *tick, struct block_list **src, struct unit_data **ud, struct skill_timerskill **skl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_notarget_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_timerskill_notarget_unknown_pre[hIndex].func;
			preHookFunc(&tid, &tick, &src, &ud, &skl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.timerskill_notarget_unknown(tid, tick, src, ud, skl);
	}
	if( HPMHooks.count.HP_skill_timerskill_notarget_unknown_post ) {
		void (*postHookFunc) (int tid, int64 tick, struct block_list *src, struct unit_data *ud, struct skill_timerskill *skl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_timerskill_notarget_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_timerskill_notarget_unknown_post[hIndex].func;
			postHookFunc(tid, tick, src, ud, skl);
		}
	}
	return;
}
bool HP_skill_cleartimerskill_exception(int skill_id) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_cleartimerskill_exception_pre ) {
		bool (*preHookFunc) (int *skill_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_exception_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_cleartimerskill_exception_pre[hIndex].func;
			retVal___ = preHookFunc(&skill_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.cleartimerskill_exception(skill_id);
	}
	if( HPMHooks.count.HP_skill_cleartimerskill_exception_post ) {
		bool (*postHookFunc) (bool retVal___, int skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_exception_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_cleartimerskill_exception_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
bool HP_skill_castend_id_unknown(struct unit_data *ud, struct block_list *src, struct block_list *target) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_castend_id_unknown_pre ) {
		bool (*preHookFunc) (struct unit_data **ud, struct block_list **src, struct block_list **target);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_id_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&ud, &src, &target);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_id_unknown(ud, src, target);
	}
	if( HPMHooks.count.HP_skill_castend_id_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct unit_data *ud, struct block_list *src, struct block_list *target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_id_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_id_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ud, src, target);
		}
	}
	return retVal___;
}
bool HP_skill_castend_nodamage_id_dead_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_pre ) {
		bool (*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_dead_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_dead_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_nodamage_id_dead_unknown(src, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_dead_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_dead_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
bool HP_skill_castend_nodamage_id_undead_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_pre ) {
		bool (*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_undead_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_undead_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_nodamage_id_undead_unknown(src, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_undead_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_undead_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
bool HP_skill_castend_nodamage_id_mado_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_pre ) {
		bool (*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_mado_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_mado_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_nodamage_id_mado_unknown(src, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_mado_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_mado_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
bool HP_skill_castend_nodamage_id_unknown(struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_castend_nodamage_id_unknown_pre ) {
		bool (*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_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &bl, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_nodamage_id_unknown(src, bl, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_nodamage_id_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, struct block_list *bl, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_nodamage_id_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_nodamage_id_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
void HP_skill_castend_pos2_effect_unknown(struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_castend_pos2_effect_unknown_pre ) {
		void (*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_effect_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_pos2_effect_unknown_pre[hIndex].func;
			preHookFunc(&src, &x, &y, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.castend_pos2_effect_unknown(src, x, y, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_pos2_effect_unknown_post ) {
		void (*postHookFunc) (struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_effect_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_pos2_effect_unknown_post[hIndex].func;
			postHookFunc(src, x, y, skill_id, skill_lv, tick, flag);
		}
	}
	return;
}
bool HP_skill_castend_pos2_unknown(struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_castend_pos2_unknown_pre ) {
		bool (*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_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_castend_pos2_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&src, &x, &y, &skill_id, &skill_lv, &tick, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.castend_pos2_unknown(src, x, y, skill_id, skill_lv, tick, flag);
	}
	if( HPMHooks.count.HP_skill_castend_pos2_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *src, int *x, int *y, uint16 *skill_id, uint16 *skill_lv, int64 *tick, int *flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_castend_pos2_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_castend_pos2_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, x, y, skill_id, skill_lv, tick, flag);
		}
	}
	return retVal___;
}
void HP_skill_unitsetting1_unknown(struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_unitsetting1_unknown_pre ) {
		void (*preHookFunc) (struct block_list **src, uint16 **skill_id, uint16 **skill_lv, int16 **x, int16 **y, int **flag, int **val1, int **val2, int **val3);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting1_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_unitsetting1_unknown_pre[hIndex].func;
			preHookFunc(&src, &skill_id, &skill_lv, &x, &y, &flag, &val1, &val2, &val3);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.unitsetting1_unknown(src, skill_id, skill_lv, x, y, flag, val1, val2, val3);
	}
	if( HPMHooks.count.HP_skill_unitsetting1_unknown_post ) {
		void (*postHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *val1, int *val2, int *val3);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting1_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unitsetting1_unknown_post[hIndex].func;
			postHookFunc(src, skill_id, skill_lv, x, y, flag, val1, val2, val3);
		}
	}
	return;
}
void HP_skill_unitsetting2_unknown(struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_unitsetting2_unknown_pre ) {
		void (*preHookFunc) (struct block_list **src, uint16 **skill_id, uint16 **skill_lv, int16 **x, int16 **y, int **flag, int **unit_flag, int **val1, int **val2, int **val3, struct skill_unit_group **group);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting2_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_unitsetting2_unknown_pre[hIndex].func;
			preHookFunc(&src, &skill_id, &skill_lv, &x, &y, &flag, &unit_flag, &val1, &val2, &val3, &group);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.unitsetting2_unknown(src, skill_id, skill_lv, x, y, flag, unit_flag, val1, val2, val3, group);
	}
	if( HPMHooks.count.HP_skill_unitsetting2_unknown_post ) {
		void (*postHookFunc) (struct block_list *src, uint16 *skill_id, uint16 *skill_lv, int16 *x, int16 *y, int *flag, int *unit_flag, int *val1, int *val2, int *val3, struct skill_unit_group *group);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unitsetting2_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unitsetting2_unknown_post[hIndex].func;
			postHookFunc(src, skill_id, skill_lv, x, y, flag, unit_flag, val1, val2, val3, group);
		}
	}
	return;
}
void HP_skill_unit_onplace_unknown(struct skill_unit *src, struct block_list *bl, int64 *tick) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_unit_onplace_unknown_pre ) {
		void (*preHookFunc) (struct skill_unit **src, struct block_list **bl, int64 **tick);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_unit_onplace_unknown_pre[hIndex].func;
			preHookFunc(&src, &bl, &tick);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.unit_onplace_unknown(src, bl, tick);
	}
	if( HPMHooks.count.HP_skill_unit_onplace_unknown_post ) {
		void (*postHookFunc) (struct skill_unit *src, struct block_list *bl, int64 *tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_unit_onplace_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_unit_onplace_unknown_post[hIndex].func;
			postHookFunc(src, bl, tick);
		}
	}
	return;
}
int HP_skill_check_condition_castbegin_off_unknown(struct status_change *sc, uint16 *skill_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_pre ) {
		int (*preHookFunc) (struct status_change **sc, uint16 **skill_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_off_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&sc, &skill_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_condition_castbegin_off_unknown(sc, skill_id);
	}
	if( HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_post ) {
		int (*postHookFunc) (int retVal___, struct status_change *sc, uint16 *skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_off_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_off_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sc, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_check_condition_castbegin_mount_unknown(struct status_change *sc, uint16 *skill_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_pre ) {
		int (*preHookFunc) (struct status_change **sc, uint16 **skill_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_mount_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&sc, &skill_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_condition_castbegin_mount_unknown(sc, skill_id);
	}
	if( HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_post ) {
		int (*postHookFunc) (int retVal___, struct status_change *sc, uint16 *skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_mount_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_mount_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sc, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_check_condition_castbegin_madogear_unknown(struct status_change *sc, uint16 *skill_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_pre ) {
		int (*preHookFunc) (struct status_change **sc, uint16 **skill_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_madogear_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&sc, &skill_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_condition_castbegin_madogear_unknown(sc, skill_id);
	}
	if( HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_post ) {
		int (*postHookFunc) (int retVal___, struct status_change *sc, uint16 *skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_madogear_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_madogear_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sc, skill_id);
		}
	}
	return retVal___;
}
int HP_skill_check_condition_castbegin_unknown(struct status_change *sc, uint16 *skill_id) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_check_condition_castbegin_unknown_pre ) {
		int (*preHookFunc) (struct status_change **sc, uint16 **skill_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&sc, &skill_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.check_condition_castbegin_unknown(sc, skill_id);
	}
	if( HPMHooks.count.HP_skill_check_condition_castbegin_unknown_post ) {
		int (*postHookFunc) (int retVal___, struct status_change *sc, uint16 *skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castbegin_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_condition_castbegin_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sc, skill_id);
		}
	}
	return retVal___;
}
void HP_skill_check_condition_castend_unknown(struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_check_condition_castend_unknown_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_check_condition_castend_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_check_condition_castend_unknown_pre[hIndex].func;
			preHookFunc(&sd, &skill_id, &skill_lv);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.check_condition_castend_unknown(sd, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_skill_check_condition_castend_unknown_post ) {
		void (*postHookFunc) (struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_condition_castend_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_check_condition_castend_unknown_post[hIndex].func;
			postHookFunc(sd, skill_id, skill_lv);
		}
	}
	return;
}
bool HP_skill_get_requirement_off_unknown(struct status_change *sc, uint16 *skill_id) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_get_requirement_off_unknown_pre ) {
		bool (*preHookFunc) (struct status_change **sc, uint16 **skill_id);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_off_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_get_requirement_off_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&sc, &skill_id);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_requirement_off_unknown(sc, skill_id);
	}
	if( HPMHooks.count.HP_skill_get_requirement_off_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct status_change *sc, uint16 *skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_off_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_requirement_off_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sc, skill_id);
		}
	}
	return retVal___;
}
bool HP_skill_get_requirement_item_unknown(struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_skill_get_requirement_item_unknown_pre ) {
		bool (*preHookFunc) (struct status_change **sc, struct map_session_data **sd, uint16 **skill_id, uint16 **skill_lv, uint16 **idx, int **i);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_item_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_get_requirement_item_unknown_pre[hIndex].func;
			retVal___ = preHookFunc(&sc, &sd, &skill_id, &skill_lv, &idx, &i);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.get_requirement_item_unknown(sc, sd, skill_id, skill_lv, idx, i);
	}
	if( HPMHooks.count.HP_skill_get_requirement_item_unknown_post ) {
		bool (*postHookFunc) (bool retVal___, struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, uint16 *idx, int *i);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_item_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_requirement_item_unknown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sc, sd, skill_id, skill_lv, idx, i);
		}
	}
	return retVal___;
}
void HP_skill_get_requirement_unknown(struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req) {
	int hIndex = 0;
	if( HPMHooks.count.HP_skill_get_requirement_unknown_pre ) {
		void (*preHookFunc) (struct status_change **sc, struct map_session_data **sd, uint16 **skill_id, uint16 **skill_lv, struct skill_condition **req);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_unknown_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_get_requirement_unknown_pre[hIndex].func;
			preHookFunc(&sc, &sd, &skill_id, &skill_lv, &req);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.skill.get_requirement_unknown(sc, sd, skill_id, skill_lv, req);
	}
	if( HPMHooks.count.HP_skill_get_requirement_unknown_post ) {
		void (*postHookFunc) (struct status_change *sc, struct map_session_data *sd, uint16 *skill_id, uint16 *skill_lv, struct skill_condition *req);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_get_requirement_unknown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_get_requirement_unknown_post[hIndex].func;
			postHookFunc(sc, sd, skill_id, skill_lv, req);
		}
	}
	return;
}
int HP_skill_splash_target(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_splash_target_pre ) {
		int (*preHookFunc) (struct block_list **bl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_splash_target_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_skill_splash_target_pre[hIndex].func;
			retVal___ = preHookFunc(&bl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.skill.splash_target(bl);
	}
	if( HPMHooks.count.HP_skill_splash_target_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_splash_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_skill_splash_target_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_skill_check_npc_chaospanic(struct block_list *bl, va_list args) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_check_npc_chaospanic_pre ) {
		int (*preHookFunc) (struct block_list **bl, va_list args);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_npc_chaospanic_pre; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			preHookFunc = HPMHooks.list.HP_skill_check_npc_chaospanic_pre[hIndex].func;
			retVal___ = preHookFunc(&bl, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.skill.check_npc_chaospanic(bl, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_skill_check_npc_chaospanic_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_check_npc_chaospanic_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_skill_check_npc_chaospanic_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_skill_count_wos(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_skill_count_wos_pre ) {
		int (*preHookFunc) (struct block_list **bl, va_list ap);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_count_wos_pre; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			preHookFunc = HPMHooks.list.HP_skill_count_wos_pre[hIndex].func;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.skill.count_wos(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_skill_count_wos_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_count_wos_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_skill_count_wos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
/* socket_interface */
void HP_sockt_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.init();
	}
	if( HPMHooks.count.HP_sockt_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_sockt_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.final();
	}
	if( HPMHooks.count.HP_sockt_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_sockt_perform(int next) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_perform_pre ) {
		int (*preHookFunc) (int *next);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_perform_pre[hIndex].func;
			retVal___ = preHookFunc(&next);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.perform(next);
	}
	if( HPMHooks.count.HP_sockt_perform_post ) {
		int (*postHookFunc) (int retVal___, int next);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_perform_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_perform_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, next);
		}
	}
	return retVal___;
}
void HP_sockt_datasync(int fd, bool send) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_datasync_pre ) {
		void (*preHookFunc) (int *fd, bool *send);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_datasync_pre[hIndex].func;
			preHookFunc(&fd, &send);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.datasync(fd, send);
	}
	if( HPMHooks.count.HP_sockt_datasync_post ) {
		void (*postHookFunc) (int fd, bool send);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_datasync_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_datasync_post[hIndex].func;
			postHookFunc(fd, send);
		}
	}
	return;
}
int HP_sockt_make_listen_bind(uint32 ip, uint16 port) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_make_listen_bind_pre ) {
		int (*preHookFunc) (uint32 *ip, uint16 *port);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_pre[hIndex].func;
			retVal___ = preHookFunc(&ip, &port);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.make_listen_bind(ip, port);
	}
	if( HPMHooks.count.HP_sockt_make_listen_bind_post ) {
		int (*postHookFunc) (int retVal___, uint32 ip, uint16 port);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_listen_bind_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_make_listen_bind_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip, port);
		}
	}
	return retVal___;
}
int HP_sockt_make_connection(uint32 ip, uint16 port, struct hSockOpt *opt) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_make_connection_pre ) {
		int (*preHookFunc) (uint32 *ip, uint16 *port, struct hSockOpt **opt);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_make_connection_pre[hIndex].func;
			retVal___ = preHookFunc(&ip, &port, &opt);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.make_connection(ip, port, opt);
	}
	if( HPMHooks.count.HP_sockt_make_connection_post ) {
		int (*postHookFunc) (int retVal___, uint32 ip, uint16 port, struct hSockOpt *opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_make_connection_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_make_connection_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip, port, opt);
		}
	}
	return retVal___;
}
int HP_sockt_realloc_fifo(int fd, unsigned int rfifo_size, unsigned int wfifo_size) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_realloc_fifo_pre ) {
		int (*preHookFunc) (int *fd, unsigned int *rfifo_size, unsigned int *wfifo_size);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_pre[hIndex].func;
			retVal___ = preHookFunc(&fd, &rfifo_size, &wfifo_size);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.realloc_fifo(fd, rfifo_size, wfifo_size);
	}
	if( HPMHooks.count.HP_sockt_realloc_fifo_post ) {
		int (*postHookFunc) (int retVal___, int fd, unsigned int rfifo_size, unsigned int wfifo_size);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_fifo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_realloc_fifo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd, rfifo_size, wfifo_size);
		}
	}
	return retVal___;
}
int HP_sockt_realloc_writefifo(int fd, size_t addition) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_realloc_writefifo_pre ) {
		int (*preHookFunc) (int *fd, size_t *addition);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_pre[hIndex].func;
			retVal___ = preHookFunc(&fd, &addition);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.realloc_writefifo(fd, addition);
	}
	if( HPMHooks.count.HP_sockt_realloc_writefifo_post ) {
		int (*postHookFunc) (int retVal___, int fd, size_t addition);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_realloc_writefifo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_realloc_writefifo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd, addition);
		}
	}
	return retVal___;
}
int HP_sockt_wfifoset(int fd, size_t len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_wfifoset_pre ) {
		int (*preHookFunc) (int *fd, size_t *len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_wfifoset_pre[hIndex].func;
			retVal___ = preHookFunc(&fd, &len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.wfifoset(fd, len);
	}
	if( HPMHooks.count.HP_sockt_wfifoset_post ) {
		int (*postHookFunc) (int retVal___, int fd, size_t len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_wfifoset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_wfifoset_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd, len);
		}
	}
	return retVal___;
}
int HP_sockt_rfifoskip(int fd, size_t len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_rfifoskip_pre ) {
		int (*preHookFunc) (int *fd, size_t *len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_rfifoskip_pre[hIndex].func;
			retVal___ = preHookFunc(&fd, &len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.rfifoskip(fd, len);
	}
	if( HPMHooks.count.HP_sockt_rfifoskip_post ) {
		int (*postHookFunc) (int retVal___, int fd, size_t len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_rfifoskip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_rfifoskip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd, len);
		}
	}
	return retVal___;
}
void HP_sockt_close(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_close_pre ) {
		void (*preHookFunc) (int *fd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_close_pre[hIndex].func;
			preHookFunc(&fd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.close(fd);
	}
	if( HPMHooks.count.HP_sockt_close_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_close_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
bool HP_sockt_session_is_valid(int fd) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_sockt_session_is_valid_pre ) {
		bool (*preHookFunc) (int *fd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_session_is_valid_pre[hIndex].func;
			retVal___ = preHookFunc(&fd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.session_is_valid(fd);
	}
	if( HPMHooks.count.HP_sockt_session_is_valid_post ) {
		bool (*postHookFunc) (bool retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_valid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_session_is_valid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
bool HP_sockt_session_is_active(int fd) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_sockt_session_is_active_pre ) {
		bool (*preHookFunc) (int *fd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_session_is_active_pre[hIndex].func;
			retVal___ = preHookFunc(&fd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.session_is_active(fd);
	}
	if( HPMHooks.count.HP_sockt_session_is_active_post ) {
		bool (*postHookFunc) (bool retVal___, int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_session_is_active_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_session_is_active_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fd);
		}
	}
	return retVal___;
}
void HP_sockt_flush(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_flush_pre ) {
		void (*preHookFunc) (int *fd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_flush_pre[hIndex].func;
			preHookFunc(&fd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.flush(fd);
	}
	if( HPMHooks.count.HP_sockt_flush_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_flush_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
void HP_sockt_flush_fifos(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_flush_fifos_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_fifos_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_flush_fifos_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.flush_fifos();
	}
	if( HPMHooks.count.HP_sockt_flush_fifos_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_flush_fifos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_flush_fifos_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_sockt_set_nonblocking(int fd, unsigned long yes) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_set_nonblocking_pre ) {
		void (*preHookFunc) (int *fd, unsigned long *yes);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_pre[hIndex].func;
			preHookFunc(&fd, &yes);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.set_nonblocking(fd, yes);
	}
	if( HPMHooks.count.HP_sockt_set_nonblocking_post ) {
		void (*postHookFunc) (int fd, unsigned long yes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_nonblocking_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_set_nonblocking_post[hIndex].func;
			postHookFunc(fd, yes);
		}
	}
	return;
}
void HP_sockt_set_defaultparse(ParseFunc defaultparse) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_set_defaultparse_pre ) {
		void (*preHookFunc) (ParseFunc *defaultparse);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_pre[hIndex].func;
			preHookFunc(&defaultparse);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.set_defaultparse(defaultparse);
	}
	if( HPMHooks.count.HP_sockt_set_defaultparse_post ) {
		void (*postHookFunc) (ParseFunc defaultparse);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_set_defaultparse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_set_defaultparse_post[hIndex].func;
			postHookFunc(defaultparse);
		}
	}
	return;
}
uint32 HP_sockt_host2ip(const char *hostname) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_sockt_host2ip_pre ) {
		uint32 (*preHookFunc) (const char **hostname);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_host2ip_pre[hIndex].func;
			retVal___ = preHookFunc(&hostname);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.host2ip(hostname);
	}
	if( HPMHooks.count.HP_sockt_host2ip_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, const char *hostname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_host2ip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_host2ip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hostname);
		}
	}
	return retVal___;
}
const char* HP_sockt_ip2str(uint32 ip, char *ip_str) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sockt_ip2str_pre ) {
		const char* (*preHookFunc) (uint32 *ip, char **ip_str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_ip2str_pre[hIndex].func;
			retVal___ = preHookFunc(&ip, &ip_str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.ip2str(ip, ip_str);
	}
	if( HPMHooks.count.HP_sockt_ip2str_post ) {
		const char* (*postHookFunc) (const char* retVal___, uint32 ip, char *ip_str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ip2str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_ip2str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip, ip_str);
		}
	}
	return retVal___;
}
uint32 HP_sockt_str2ip(const char *ip_str) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_sockt_str2ip_pre ) {
		uint32 (*preHookFunc) (const char **ip_str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_str2ip_pre[hIndex].func;
			retVal___ = preHookFunc(&ip_str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.str2ip(ip_str);
	}
	if( HPMHooks.count.HP_sockt_str2ip_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, const char *ip_str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_str2ip_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_str2ip_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip_str);
		}
	}
	return retVal___;
}
uint16 HP_sockt_ntows(uint16 netshort) {
	int hIndex = 0;
	uint16 retVal___ = 0;
	if( HPMHooks.count.HP_sockt_ntows_pre ) {
		uint16 (*preHookFunc) (uint16 *netshort);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_ntows_pre[hIndex].func;
			retVal___ = preHookFunc(&netshort);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.ntows(netshort);
	}
	if( HPMHooks.count.HP_sockt_ntows_post ) {
		uint16 (*postHookFunc) (uint16 retVal___, uint16 netshort);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_ntows_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_ntows_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, netshort);
		}
	}
	return retVal___;
}
int HP_sockt_getips(uint32 *ips, int max) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_getips_pre ) {
		int (*preHookFunc) (uint32 **ips, int *max);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_getips_pre[hIndex].func;
			retVal___ = preHookFunc(&ips, &max);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.getips(ips, max);
	}
	if( HPMHooks.count.HP_sockt_getips_post ) {
		int (*postHookFunc) (int retVal___, uint32 *ips, int max);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_getips_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_getips_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ips, max);
		}
	}
	return retVal___;
}
void HP_sockt_eof(int fd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_eof_pre ) {
		void (*preHookFunc) (int *fd);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_eof_pre[hIndex].func;
			preHookFunc(&fd);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.eof(fd);
	}
	if( HPMHooks.count.HP_sockt_eof_post ) {
		void (*postHookFunc) (int fd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_eof_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_eof_post[hIndex].func;
			postHookFunc(fd);
		}
	}
	return;
}
uint32 HP_sockt_lan_subnet_check(uint32 ip, struct s_subnet *info) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_sockt_lan_subnet_check_pre ) {
		uint32 (*preHookFunc) (uint32 *ip, struct s_subnet **info);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_pre[hIndex].func;
			retVal___ = preHookFunc(&ip, &info);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.lan_subnet_check(ip, info);
	}
	if( HPMHooks.count.HP_sockt_lan_subnet_check_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, uint32 ip, struct s_subnet *info);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_lan_subnet_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_lan_subnet_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip, info);
		}
	}
	return retVal___;
}
bool HP_sockt_allowed_ip_check(uint32 ip) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_sockt_allowed_ip_check_pre ) {
		bool (*preHookFunc) (uint32 *ip);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_pre[hIndex].func;
			retVal___ = preHookFunc(&ip);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.allowed_ip_check(ip);
	}
	if( HPMHooks.count.HP_sockt_allowed_ip_check_post ) {
		bool (*postHookFunc) (bool retVal___, uint32 ip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_allowed_ip_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_allowed_ip_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip);
		}
	}
	return retVal___;
}
bool HP_sockt_trusted_ip_check(uint32 ip) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_sockt_trusted_ip_check_pre ) {
		bool (*preHookFunc) (uint32 *ip);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_pre[hIndex].func;
			retVal___ = preHookFunc(&ip);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.trusted_ip_check(ip);
	}
	if( HPMHooks.count.HP_sockt_trusted_ip_check_post ) {
		bool (*postHookFunc) (bool retVal___, uint32 ip);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_trusted_ip_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_trusted_ip_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ip);
		}
	}
	return retVal___;
}
int HP_sockt_net_config_read_sub(struct config_setting_t *t, struct s_subnet_vector *list, const char *filename, const char *groupname) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sockt_net_config_read_sub_pre ) {
		int (*preHookFunc) (struct config_setting_t **t, struct s_subnet_vector **list, const char **filename, const char **groupname);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&t, &list, &filename, &groupname);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sockt.net_config_read_sub(t, list, filename, groupname);
	}
	if( HPMHooks.count.HP_sockt_net_config_read_sub_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *t, struct s_subnet_vector *list, const char *filename, const char *groupname);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_net_config_read_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, t, list, filename, groupname);
		}
	}
	return retVal___;
}
void HP_sockt_net_config_read(const char *filename) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sockt_net_config_read_pre ) {
		void (*preHookFunc) (const char **filename);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sockt_net_config_read_pre[hIndex].func;
			preHookFunc(&filename);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sockt.net_config_read(filename);
	}
	if( HPMHooks.count.HP_sockt_net_config_read_post ) {
		void (*postHookFunc) (const char *filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sockt_net_config_read_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sockt_net_config_read_post[hIndex].func;
			postHookFunc(filename);
		}
	}
	return;
}
/* sql_interface */
int HP_SQL_Connect(struct Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_Connect_pre ) {
		int (*preHookFunc) (struct Sql **self, const char **user, const char **passwd, const char **host, uint16 *port, const char **db);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_Connect_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &user, &passwd, &host, &port, &db);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.Connect(self, user, passwd, host, port, db);
	}
	if( HPMHooks.count.HP_SQL_Connect_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self, const char *user, const char *passwd, const char *host, uint16 port, const char *db);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Connect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_Connect_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, user, passwd, host, port, db);
		}
	}
	return retVal___;
}
int HP_SQL_GetTimeout(struct Sql *self, uint32 *out_timeout) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_GetTimeout_pre ) {
		int (*preHookFunc) (struct Sql **self, uint32 **out_timeout);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_GetTimeout_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &out_timeout);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.GetTimeout(self, out_timeout);
	}
	if( HPMHooks.count.HP_SQL_GetTimeout_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self, uint32 *out_timeout);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetTimeout_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_GetTimeout_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, out_timeout);
		}
	}
	return retVal___;
}
int HP_SQL_GetColumnNames(struct Sql *self, const char *table, char *out_buf, size_t buf_len, char sep) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_GetColumnNames_pre ) {
		int (*preHookFunc) (struct Sql **self, const char **table, char **out_buf, size_t *buf_len, char *sep);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &table, &out_buf, &buf_len, &sep);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.GetColumnNames(self, table, out_buf, buf_len, sep);
	}
	if( HPMHooks.count.HP_SQL_GetColumnNames_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self, const char *table, char *out_buf, size_t buf_len, char sep);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetColumnNames_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_GetColumnNames_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, table, out_buf, buf_len, sep);
		}
	}
	return retVal___;
}
int HP_SQL_SetEncoding(struct Sql *self, const char *encoding) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_SetEncoding_pre ) {
		int (*preHookFunc) (struct Sql **self, const char **encoding);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_SetEncoding_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &encoding);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.SetEncoding(self, encoding);
	}
	if( HPMHooks.count.HP_SQL_SetEncoding_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self, const char *encoding);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_SetEncoding_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_SetEncoding_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, encoding);
		}
	}
	return retVal___;
}
int HP_SQL_Ping(struct Sql *self) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_Ping_pre ) {
		int (*preHookFunc) (struct Sql **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_Ping_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.Ping(self);
	}
	if( HPMHooks.count.HP_SQL_Ping_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Ping_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_Ping_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
size_t HP_SQL_EscapeString(struct Sql *self, char *out_to, const char *from) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_SQL_EscapeString_pre ) {
		size_t (*preHookFunc) (struct Sql **self, char **out_to, const char **from);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_EscapeString_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &out_to, &from);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.EscapeString(self, out_to, from);
	}
	if( HPMHooks.count.HP_SQL_EscapeString_post ) {
		size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeString_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_EscapeString_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, out_to, from);
		}
	}
	return retVal___;
}
size_t HP_SQL_EscapeStringLen(struct Sql *self, char *out_to, const char *from, size_t from_len) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_SQL_EscapeStringLen_pre ) {
		size_t (*preHookFunc) (struct Sql **self, char **out_to, const char **from, size_t *from_len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &out_to, &from, &from_len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.EscapeStringLen(self, out_to, from, from_len);
	}
	if( HPMHooks.count.HP_SQL_EscapeStringLen_post ) {
		size_t (*postHookFunc) (size_t retVal___, struct Sql *self, char *out_to, const char *from, size_t from_len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_EscapeStringLen_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_EscapeStringLen_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, out_to, from, from_len);
		}
	}
	return retVal___;
}
int HP_SQL_QueryV(struct Sql *self, const char *query, va_list args) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_QueryV_pre ) {
		int (*preHookFunc) (struct Sql **self, const char **query, va_list args);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_pre; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			preHookFunc = HPMHooks.list.HP_SQL_QueryV_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &query, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.SQL.QueryV(self, query, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_SQL_QueryV_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self, const char *query, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryV_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_SQL_QueryV_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, query, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_SQL_QueryStr(struct Sql *self, const char *query) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_QueryStr_pre ) {
		int (*preHookFunc) (struct Sql **self, const char **query);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_QueryStr_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &query);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.QueryStr(self, query);
	}
	if( HPMHooks.count.HP_SQL_QueryStr_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self, const char *query);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_QueryStr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_QueryStr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, query);
		}
	}
	return retVal___;
}
uint64 HP_SQL_LastInsertId(struct Sql *self) {
	int hIndex = 0;
	uint64 retVal___ = 0;
	if( HPMHooks.count.HP_SQL_LastInsertId_pre ) {
		uint64 (*preHookFunc) (struct Sql **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_LastInsertId_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.LastInsertId(self);
	}
	if( HPMHooks.count.HP_SQL_LastInsertId_post ) {
		uint64 (*postHookFunc) (uint64 retVal___, struct Sql *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_LastInsertId_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_LastInsertId_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
uint32 HP_SQL_NumColumns(struct Sql *self) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_SQL_NumColumns_pre ) {
		uint32 (*preHookFunc) (struct Sql **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_NumColumns_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.NumColumns(self);
	}
	if( HPMHooks.count.HP_SQL_NumColumns_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, struct Sql *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumColumns_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_NumColumns_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
uint64 HP_SQL_NumRows(struct Sql *self) {
	int hIndex = 0;
	uint64 retVal___ = 0;
	if( HPMHooks.count.HP_SQL_NumRows_pre ) {
		uint64 (*preHookFunc) (struct Sql **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_NumRows_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.NumRows(self);
	}
	if( HPMHooks.count.HP_SQL_NumRows_post ) {
		uint64 (*postHookFunc) (uint64 retVal___, struct Sql *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NumRows_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_NumRows_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
int HP_SQL_NextRow(struct Sql *self) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_NextRow_pre ) {
		int (*preHookFunc) (struct Sql **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_NextRow_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.NextRow(self);
	}
	if( HPMHooks.count.HP_SQL_NextRow_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_NextRow_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_NextRow_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
int HP_SQL_GetData(struct Sql *self, size_t col, char **out_buf, size_t *out_len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_GetData_pre ) {
		int (*preHookFunc) (struct Sql **self, size_t *col, char ***out_buf, size_t **out_len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_GetData_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &col, &out_buf, &out_len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.GetData(self, col, out_buf, out_len);
	}
	if( HPMHooks.count.HP_SQL_GetData_post ) {
		int (*postHookFunc) (int retVal___, struct Sql *self, size_t col, char **out_buf, size_t *out_len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_GetData_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_GetData_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, col, out_buf, out_len);
		}
	}
	return retVal___;
}
void HP_SQL_FreeResult(struct Sql *self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_SQL_FreeResult_pre ) {
		void (*preHookFunc) (struct Sql **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_FreeResult_pre[hIndex].func;
			preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.SQL.FreeResult(self);
	}
	if( HPMHooks.count.HP_SQL_FreeResult_post ) {
		void (*postHookFunc) (struct Sql *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_FreeResult_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_FreeResult_post[hIndex].func;
			postHookFunc(self);
		}
	}
	return;
}
void HP_SQL_ShowDebug_(struct Sql *self, const char *debug_file, const unsigned long debug_line) {
	int hIndex = 0;
	if( HPMHooks.count.HP_SQL_ShowDebug__pre ) {
		void (*preHookFunc) (struct Sql **self, const char **debug_file, const unsigned long *debug_line);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_ShowDebug__pre[hIndex].func;
			preHookFunc(&self, &debug_file, &debug_line);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.SQL.ShowDebug_(self, debug_file, debug_line);
	}
	if( HPMHooks.count.HP_SQL_ShowDebug__post ) {
		void (*postHookFunc) (struct Sql *self, const char *debug_file, const unsigned long debug_line);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_ShowDebug__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_ShowDebug__post[hIndex].func;
			postHookFunc(self, debug_file, debug_line);
		}
	}
	return;
}
void HP_SQL_Free(struct Sql *self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_SQL_Free_pre ) {
		void (*preHookFunc) (struct Sql **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_Free_pre[hIndex].func;
			preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.SQL.Free(self);
	}
	if( HPMHooks.count.HP_SQL_Free_post ) {
		void (*postHookFunc) (struct Sql *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Free_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_Free_post[hIndex].func;
			postHookFunc(self);
		}
	}
	return;
}
struct Sql* HP_SQL_Malloc(void) {
	int hIndex = 0;
	struct Sql* retVal___ = NULL;
	if( HPMHooks.count.HP_SQL_Malloc_pre ) {
		struct Sql* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Malloc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_Malloc_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.Malloc();
	}
	if( HPMHooks.count.HP_SQL_Malloc_post ) {
		struct Sql* (*postHookFunc) (struct Sql* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_Malloc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_Malloc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
struct SqlStmt* HP_SQL_StmtMalloc(struct Sql *sql) {
	int hIndex = 0;
	struct SqlStmt* retVal___ = NULL;
	if( HPMHooks.count.HP_SQL_StmtMalloc_pre ) {
		struct SqlStmt* (*preHookFunc) (struct Sql **sql);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_pre[hIndex].func;
			retVal___ = preHookFunc(&sql);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtMalloc(sql);
	}
	if( HPMHooks.count.HP_SQL_StmtMalloc_post ) {
		struct SqlStmt* (*postHookFunc) (struct SqlStmt* retVal___, struct Sql *sql);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtMalloc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtMalloc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sql);
		}
	}
	return retVal___;
}
int HP_SQL_StmtPrepareV(struct SqlStmt *self, const char *query, va_list args) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtPrepareV_pre ) {
		int (*preHookFunc) (struct SqlStmt **self, const char **query, va_list args);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_pre; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &query, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.SQL.StmtPrepareV(self, query, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_SQL_StmtPrepareV_post ) {
		int (*postHookFunc) (int retVal___, struct SqlStmt *self, const char *query, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareV_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_SQL_StmtPrepareV_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, query, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_SQL_StmtPrepareStr(struct SqlStmt *self, const char *query) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtPrepareStr_pre ) {
		int (*preHookFunc) (struct SqlStmt **self, const char **query);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &query);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtPrepareStr(self, query);
	}
	if( HPMHooks.count.HP_SQL_StmtPrepareStr_post ) {
		int (*postHookFunc) (int retVal___, struct SqlStmt *self, const char *query);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtPrepareStr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtPrepareStr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, query);
		}
	}
	return retVal___;
}
size_t HP_SQL_StmtNumParams(struct SqlStmt *self) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtNumParams_pre ) {
		size_t (*preHookFunc) (struct SqlStmt **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtNumParams(self);
	}
	if( HPMHooks.count.HP_SQL_StmtNumParams_post ) {
		size_t (*postHookFunc) (size_t retVal___, struct SqlStmt *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumParams_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtNumParams_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
int HP_SQL_StmtBindParam(struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, const void *buffer, size_t buffer_len) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtBindParam_pre ) {
		int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, const void **buffer, size_t *buffer_len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtBindParam(self, idx, buffer_type, buffer, buffer_len);
	}
	if( HPMHooks.count.HP_SQL_StmtBindParam_post ) {
		int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, const void *buffer, size_t buffer_len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindParam_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtBindParam_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len);
		}
	}
	return retVal___;
}
int HP_SQL_StmtExecute(struct SqlStmt *self) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtExecute_pre ) {
		int (*preHookFunc) (struct SqlStmt **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtExecute_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtExecute(self);
	}
	if( HPMHooks.count.HP_SQL_StmtExecute_post ) {
		int (*postHookFunc) (int retVal___, struct SqlStmt *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtExecute_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtExecute_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
uint64 HP_SQL_StmtLastInsertId(struct SqlStmt *self) {
	int hIndex = 0;
	uint64 retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtLastInsertId_pre ) {
		uint64 (*preHookFunc) (struct SqlStmt **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtLastInsertId(self);
	}
	if( HPMHooks.count.HP_SQL_StmtLastInsertId_post ) {
		uint64 (*postHookFunc) (uint64 retVal___, struct SqlStmt *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtLastInsertId_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtLastInsertId_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
size_t HP_SQL_StmtNumColumns(struct SqlStmt *self) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtNumColumns_pre ) {
		size_t (*preHookFunc) (struct SqlStmt **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtNumColumns(self);
	}
	if( HPMHooks.count.HP_SQL_StmtNumColumns_post ) {
		size_t (*postHookFunc) (size_t retVal___, struct SqlStmt *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumColumns_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtNumColumns_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
int HP_SQL_StmtBindColumn(struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtBindColumn_pre ) {
		int (*preHookFunc) (struct SqlStmt **self, size_t *idx, enum SqlDataType *buffer_type, void **buffer, size_t *buffer_len, uint32 **out_length, int8 **out_is_null);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &idx, &buffer_type, &buffer, &buffer_len, &out_length, &out_is_null);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtBindColumn(self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null);
	}
	if( HPMHooks.count.HP_SQL_StmtBindColumn_post ) {
		int (*postHookFunc) (int retVal___, struct SqlStmt *self, size_t idx, enum SqlDataType buffer_type, void *buffer, size_t buffer_len, uint32 *out_length, int8 *out_is_null);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtBindColumn_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtBindColumn_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, idx, buffer_type, buffer, buffer_len, out_length, out_is_null);
		}
	}
	return retVal___;
}
uint64 HP_SQL_StmtNumRows(struct SqlStmt *self) {
	int hIndex = 0;
	uint64 retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtNumRows_pre ) {
		uint64 (*preHookFunc) (struct SqlStmt **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtNumRows(self);
	}
	if( HPMHooks.count.HP_SQL_StmtNumRows_post ) {
		uint64 (*postHookFunc) (uint64 retVal___, struct SqlStmt *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNumRows_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtNumRows_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
int HP_SQL_StmtNextRow(struct SqlStmt *self) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_SQL_StmtNextRow_pre ) {
		int (*preHookFunc) (struct SqlStmt **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.SQL.StmtNextRow(self);
	}
	if( HPMHooks.count.HP_SQL_StmtNextRow_post ) {
		int (*postHookFunc) (int retVal___, struct SqlStmt *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtNextRow_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtNextRow_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
void HP_SQL_StmtFreeResult(struct SqlStmt *self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_SQL_StmtFreeResult_pre ) {
		void (*preHookFunc) (struct SqlStmt **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_pre[hIndex].func;
			preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.SQL.StmtFreeResult(self);
	}
	if( HPMHooks.count.HP_SQL_StmtFreeResult_post ) {
		void (*postHookFunc) (struct SqlStmt *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFreeResult_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtFreeResult_post[hIndex].func;
			postHookFunc(self);
		}
	}
	return;
}
void HP_SQL_StmtFree(struct SqlStmt *self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_SQL_StmtFree_pre ) {
		void (*preHookFunc) (struct SqlStmt **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtFree_pre[hIndex].func;
			preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.SQL.StmtFree(self);
	}
	if( HPMHooks.count.HP_SQL_StmtFree_post ) {
		void (*postHookFunc) (struct SqlStmt *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtFree_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtFree_post[hIndex].func;
			postHookFunc(self);
		}
	}
	return;
}
void HP_SQL_StmtShowDebug_(struct SqlStmt *self, const char *debug_file, const unsigned long debug_line) {
	int hIndex = 0;
	if( HPMHooks.count.HP_SQL_StmtShowDebug__pre ) {
		void (*preHookFunc) (struct SqlStmt **self, const char **debug_file, const unsigned long *debug_line);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__pre[hIndex].func;
			preHookFunc(&self, &debug_file, &debug_line);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.SQL.StmtShowDebug_(self, debug_file, debug_line);
	}
	if( HPMHooks.count.HP_SQL_StmtShowDebug__post ) {
		void (*postHookFunc) (struct SqlStmt *self, const char *debug_file, const unsigned long debug_line);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_SQL_StmtShowDebug__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_SQL_StmtShowDebug__post[hIndex].func;
			postHookFunc(self, debug_file, debug_line);
		}
	}
	return;
}
/* status_interface */
int HP_status_init(bool minimal) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.init(minimal);
	}
	if( HPMHooks.count.HP_status_init_post ) {
		int (*postHookFunc) (int retVal___, bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, minimal);
		}
	}
	return retVal___;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.final();
	}
	if( HPMHooks.count.HP_status_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_status_get_refine_chance(enum refine_type wlv, int refine) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_refine_chance(wlv, refine);
	}
	if( HPMHooks.count.HP_status_get_refine_chance_post ) {
		int (*postHookFunc) (int retVal___, enum refine_type wlv, int refine);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_refine_chance_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_refine_chance_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, wlv, refine);
		}
	}
	return retVal___;
}
sc_type HP_status_skill2sc(int skill_id) {
	int hIndex = 0;
	sc_type retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.skill2sc(skill_id);
	}
	if( HPMHooks.count.HP_status_skill2sc_post ) {
		sc_type (*postHookFunc) (sc_type retVal___, int skill_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_skill2sc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_skill2sc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, skill_id);
		}
	}
	return retVal___;
}
int HP_status_sc2skill(sc_type sc) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.sc2skill(sc);
	}
	if( HPMHooks.count.HP_status_sc2skill_post ) {
		int (*postHookFunc) (int retVal___, sc_type sc);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2skill_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_sc2skill_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sc);
		}
	}
	return retVal___;
}
unsigned int HP_status_sc2scb_flag(sc_type sc) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.sc2scb_flag(sc);
	}
	if( HPMHooks.count.HP_status_sc2scb_flag_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, sc_type sc);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_sc2scb_flag_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_sc2scb_flag_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sc);
		}
	}
	return retVal___;
}
int HP_status_type2relevant_bl_types(int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.type2relevant_bl_types(type);
	}
	if( HPMHooks.count.HP_status_type2relevant_bl_types_post ) {
		int (*postHookFunc) (int retVal___, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_type2relevant_bl_types_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_type2relevant_bl_types_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, type);
		}
	}
	return retVal___;
}
int HP_status_get_sc_type(sc_type idx) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_sc_type(idx);
	}
	if( HPMHooks.count.HP_status_get_sc_type_post ) {
		int (*postHookFunc) (int retVal___, sc_type idx);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_type_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_sc_type_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, idx);
		}
	}
	return retVal___;
}
int HP_status_damage(struct block_list *src, struct block_list *target, int64 hp, int64 sp, int walkdelay, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.damage(src, target, hp, sp, walkdelay, flag);
	}
	if( HPMHooks.count.HP_status_damage_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int64 hp, int64 sp, int walkdelay, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_damage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_damage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, hp, sp, walkdelay, flag);
		}
	}
	return retVal___;
}
int HP_status_charge(struct block_list *bl, int64 hp, int64 sp) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.charge(bl, hp, sp);
	}
	if( HPMHooks.count.HP_status_charge_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int64 hp, int64 sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_charge_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_charge_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, hp, sp);
		}
	}
	return retVal___;
}
int HP_status_percent_change(struct block_list *src, struct block_list *target, signed char hp_rate, signed char sp_rate, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.percent_change(src, target, hp_rate, sp_rate, flag);
	}
	if( HPMHooks.count.HP_status_percent_change_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, signed char hp_rate, signed char sp_rate, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_percent_change_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_percent_change_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, hp_rate, sp_rate, flag);
		}
	}
	return retVal___;
}
int HP_status_set_hp(struct block_list *bl, unsigned int hp, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.set_hp(bl, hp, flag);
	}
	if( HPMHooks.count.HP_status_set_hp_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int hp, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_hp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_set_hp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, hp, flag);
		}
	}
	return retVal___;
}
int HP_status_set_sp(struct block_list *bl, unsigned int sp, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.set_sp(bl, sp, flag);
	}
	if( HPMHooks.count.HP_status_set_sp_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int sp, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_set_sp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sp, flag);
		}
	}
	return retVal___;
}
int HP_status_heal(struct block_list *bl, int64 hp, int64 sp, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.heal(bl, hp, sp, flag);
	}
	if( HPMHooks.count.HP_status_heal_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int64 hp, int64 sp, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_heal_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_heal_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, hp, sp, flag);
		}
	}
	return retVal___;
}
int HP_status_revive(struct block_list *bl, unsigned char per_hp, unsigned char per_sp) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.revive(bl, per_hp, per_sp);
	}
	if( HPMHooks.count.HP_status_revive_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned char per_hp, unsigned char per_sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_revive_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_revive_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, per_hp, per_sp);
		}
	}
	return retVal___;
}
int HP_status_fixed_revive(struct block_list *bl, unsigned int per_hp, unsigned int per_sp) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.fixed_revive(bl, per_hp, per_sp);
	}
	if( HPMHooks.count.HP_status_fixed_revive_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned int per_hp, unsigned int per_sp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_fixed_revive_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_fixed_revive_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, per_hp, per_sp);
		}
	}
	return retVal___;
}
struct regen_data* HP_status_get_regen_data(struct block_list *bl) {
	int hIndex = 0;
	struct regen_data* retVal___ = NULL;
	if( HPMHooks.count.HP_status_get_regen_data_pre ) {
		struct regen_data* (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_regen_data(bl);
	}
	if( HPMHooks.count.HP_status_get_regen_data_post ) {
		struct regen_data* (*postHookFunc) (struct regen_data* retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_regen_data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_regen_data_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
struct status_data* HP_status_get_status_data(struct block_list *bl) {
	int hIndex = 0;
	struct status_data* retVal___ = NULL;
	if( HPMHooks.count.HP_status_get_status_data_pre ) {
		struct status_data* (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_status_data(bl);
	}
	if( HPMHooks.count.HP_status_get_status_data_post ) {
		struct status_data* (*postHookFunc) (struct status_data* retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_status_data_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_status_data_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
struct status_data* HP_status_get_base_status(struct block_list *bl) {
	int hIndex = 0;
	struct status_data* retVal___ = NULL;
	if( HPMHooks.count.HP_status_get_base_status_pre ) {
		struct status_data* (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_base_status(bl);
	}
	if( HPMHooks.count.HP_status_get_base_status_post ) {
		struct status_data* (*postHookFunc) (struct status_data* retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_status_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_base_status_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
const char* HP_status_get_name(const struct block_list *bl) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_status_get_name_pre ) {
		const char* (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_name(bl);
	}
	if( HPMHooks.count.HP_status_get_name_post ) {
		const char* (*postHookFunc) (const char* retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_name_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_name_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_get_class(const struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_class_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_class(bl);
	}
	if( HPMHooks.count.HP_status_get_class_post ) {
		int (*postHookFunc) (int retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_class_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_class_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_get_lv(const struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_lv_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_lv(bl);
	}
	if( HPMHooks.count.HP_status_get_lv_post ) {
		int (*postHookFunc) (int retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_lv_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_lv_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
defType HP_status_get_def(struct block_list *bl) {
	int hIndex = 0;
	defType retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_def(bl);
	}
	if( HPMHooks.count.HP_status_get_def_post ) {
		defType (*postHookFunc) (defType retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_def_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_def_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
unsigned short HP_status_get_speed(struct block_list *bl) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_speed(bl);
	}
	if( HPMHooks.count.HP_status_get_speed_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_speed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_speed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
unsigned char HP_status_calc_attack_element(struct block_list *bl, struct status_change *sc, int element) {
	int hIndex = 0;
	unsigned char retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_attack_element(bl, sc, element);
	}
	if( HPMHooks.count.HP_status_calc_attack_element_post ) {
		unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int element);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_attack_element_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_attack_element_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, element);
		}
	}
	return retVal___;
}
int HP_status_get_party_id(const struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_party_id_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_party_id(bl);
	}
	if( HPMHooks.count.HP_status_get_party_id_post ) {
		int (*postHookFunc) (int retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_party_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_party_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_get_guild_id(const struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_guild_id_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_guild_id(bl);
	}
	if( HPMHooks.count.HP_status_get_guild_id_post ) {
		int (*postHookFunc) (int retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_guild_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_guild_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_get_emblem_id(const struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_emblem_id_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_emblem_id(bl);
	}
	if( HPMHooks.count.HP_status_get_emblem_id_post ) {
		int (*postHookFunc) (int retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_emblem_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_emblem_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_get_mexp(const struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_mexp_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_mexp(bl);
	}
	if( HPMHooks.count.HP_status_get_mexp_post ) {
		int (*postHookFunc) (int retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_mexp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_mexp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_get_race2(const struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_race2_pre ) {
		int (*preHookFunc) (const 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_race2(bl);
	}
	if( HPMHooks.count.HP_status_get_race2_post ) {
		int (*postHookFunc) (int retVal___, const struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_race2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_race2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
struct view_data* HP_status_get_viewdata(struct block_list *bl) {
	int hIndex = 0;
	struct view_data* retVal___ = NULL;
	if( HPMHooks.count.HP_status_get_viewdata_pre ) {
		struct view_data* (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_viewdata(bl);
	}
	if( HPMHooks.count.HP_status_get_viewdata_post ) {
		struct view_data* (*postHookFunc) (struct view_data* retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_viewdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_viewdata_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
void HP_status_set_viewdata(struct block_list *bl, int class_) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_set_viewdata_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *class_);
		*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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.set_viewdata(bl, class_);
	}
	if( HPMHooks.count.HP_status_set_viewdata_post ) {
		void (*postHookFunc) (struct block_list *bl, int class_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_viewdata_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_set_viewdata_post[hIndex].func;
			postHookFunc(bl, class_);
		}
	}
	return;
}
void HP_status_change_init(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_change_init_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.change_init(bl);
	}
	if( HPMHooks.count.HP_status_change_init_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_change_init_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
struct status_change* HP_status_get_sc(struct block_list *bl) {
	int hIndex = 0;
	struct status_change* retVal___ = NULL;
	if( HPMHooks.count.HP_status_get_sc_pre ) {
		struct status_change* (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_sc(bl);
	}
	if( HPMHooks.count.HP_status_get_sc_post ) {
		struct status_change* (*postHookFunc) (struct status_change* retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_sc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_isdead(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.isdead(bl);
	}
	if( HPMHooks.count.HP_status_isdead_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isdead_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_isdead_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_isimmune(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.isimmune(bl);
	}
	if( HPMHooks.count.HP_status_isimmune_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_isimmune_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_isimmune_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_status_get_sc_def(struct block_list *src, struct block_list *bl, enum sc_type type, int rate, int tick, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_sc_def(src, bl, type, rate, tick, flag);
	}
	if( HPMHooks.count.HP_status_get_sc_def_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl, enum sc_type type, int rate, int tick, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_sc_def_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_sc_def_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, type, rate, tick, flag);
		}
	}
	return retVal___;
}
int HP_status_change_start(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) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.change_start(src, bl, type, rate, val1, val2, val3, val4, tick, flag);
	}
	if( HPMHooks.count.HP_status_change_start_post ) {
		int (*postHookFunc) (int retVal___, 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);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_start_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_change_start_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl, type, rate, val1, val2, val3, val4, tick, flag);
		}
	}
	return retVal___;
}
int HP_status_change_end_(struct block_list *bl, enum sc_type type, int tid, const char *file, int line) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.change_end_(bl, type, tid, file, line);
	}
	if( HPMHooks.count.HP_status_change_end__post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, enum sc_type type, int tid, const char *file, int line);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_end__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_change_end__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, type, tid, file, line);
		}
	}
	return retVal___;
}
int HP_status_kaahi_heal_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.kaahi_heal_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_status_kaahi_heal_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_kaahi_heal_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_kaahi_heal_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_status_change_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.change_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_status_change_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_change_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_status_change_timer_sub(struct block_list *bl, va_list ap) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.status.change_timer_sub(bl, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_status_change_timer_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_timer_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_status_change_timer_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
int HP_status_change_clear(struct block_list *bl, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.change_clear(bl, type);
	}
	if( HPMHooks.count.HP_status_change_clear_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_change_clear_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, type);
		}
	}
	return retVal___;
}
int HP_status_change_clear_buffs(struct block_list *bl, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.change_clear_buffs(bl, type);
	}
	if( HPMHooks.count.HP_status_change_clear_buffs_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_clear_buffs_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_change_clear_buffs_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, type);
		}
	}
	return retVal___;
}
void HP_status_calc_bl_(struct block_list *bl, enum scb_flag flag, enum e_status_calc_opt opt) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.calc_bl_(bl, flag, opt);
	}
	if( HPMHooks.count.HP_status_calc_bl__post ) {
		void (*postHookFunc) (struct block_list *bl, enum scb_flag flag, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_bl__post[hIndex].func;
			postHookFunc(bl, flag, opt);
		}
	}
	return;
}
int HP_status_calc_mob_(struct mob_data *md, enum e_status_calc_opt opt) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_mob_(md, opt);
	}
	if( HPMHooks.count.HP_status_calc_mob__post ) {
		int (*postHookFunc) (int retVal___, struct mob_data *md, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mob__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_mob__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, opt);
		}
	}
	return retVal___;
}
int HP_status_calc_pet_(struct pet_data *pd, enum e_status_calc_opt opt) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_pet_(pd, opt);
	}
	if( HPMHooks.count.HP_status_calc_pet__post ) {
		int (*postHookFunc) (int retVal___, struct pet_data *pd, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pet__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_pet__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pd, opt);
		}
	}
	return retVal___;
}
int HP_status_calc_pc_(struct map_session_data *sd, enum e_status_calc_opt opt) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_pc_(sd, opt);
	}
	if( HPMHooks.count.HP_status_calc_pc__post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_pc__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, opt);
		}
	}
	return retVal___;
}
void HP_status_calc_pc_additional(struct map_session_data *sd, enum e_status_calc_opt opt) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_calc_pc_additional_pre ) {
		void (*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_additional_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_calc_pc_additional_pre[hIndex].func;
			preHookFunc(&sd, &opt);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.calc_pc_additional(sd, opt);
	}
	if( HPMHooks.count.HP_status_calc_pc_additional_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_pc_additional_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_pc_additional_post[hIndex].func;
			postHookFunc(sd, opt);
		}
	}
	return;
}
int HP_status_calc_homunculus_(struct homun_data *hd, enum e_status_calc_opt opt) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_homunculus_(hd, opt);
	}
	if( HPMHooks.count.HP_status_calc_homunculus__post ) {
		int (*postHookFunc) (int retVal___, struct homun_data *hd, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_homunculus__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_homunculus__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, hd, opt);
		}
	}
	return retVal___;
}
int HP_status_calc_mercenary_(struct mercenary_data *md, enum e_status_calc_opt opt) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_mercenary_(md, opt);
	}
	if( HPMHooks.count.HP_status_calc_mercenary__post ) {
		int (*postHookFunc) (int retVal___, struct mercenary_data *md, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mercenary__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_mercenary__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, md, opt);
		}
	}
	return retVal___;
}
int HP_status_calc_elemental_(struct elemental_data *ed, enum e_status_calc_opt opt) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_elemental_(ed, opt);
	}
	if( HPMHooks.count.HP_status_calc_elemental__post ) {
		int (*postHookFunc) (int retVal___, struct elemental_data *ed, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_elemental__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_elemental__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ed, opt);
		}
	}
	return retVal___;
}
void HP_status_calc_misc(struct block_list *bl, struct status_data *st, int level) {
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.calc_misc(bl, st, level);
	}
	if( HPMHooks.count.HP_status_calc_misc_post ) {
		void (*postHookFunc) (struct block_list *bl, struct status_data *st, int level);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_misc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_misc_post[hIndex].func;
			postHookFunc(bl, st, level);
		}
	}
	return;
}
void HP_status_calc_regen(struct block_list *bl, struct status_data *st, struct regen_data *regen) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_calc_regen_pre ) {
		void (*preHookFunc) (struct block_list **bl, struct status_data **st, struct regen_data **regen);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.calc_regen(bl, st, regen);
	}
	if( HPMHooks.count.HP_status_calc_regen_post ) {
		void (*postHookFunc) (struct block_list *bl, struct status_data *st, struct regen_data *regen);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_regen_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_regen_post[hIndex].func;
			postHookFunc(bl, st, regen);
		}
	}
	return;
}
void HP_status_calc_regen_rate(struct block_list *bl, struct regen_data *regen, struct status_change *sc) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_calc_regen_rate_pre ) {
		void (*preHookFunc) (struct block_list **bl, struct regen_data **regen, struct status_change **sc);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.calc_regen_rate(bl, regen, sc);
	}
	if( HPMHooks.count.HP_status_calc_regen_rate_post ) {
		void (*postHookFunc) (struct block_list *bl, struct regen_data *regen, struct status_change *sc);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_regen_rate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_regen_rate_post[hIndex].func;
			postHookFunc(bl, regen, sc);
		}
	}
	return;
}
int HP_status_check_skilluse(struct block_list *src, struct block_list *target, uint16 skill_id, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.check_skilluse(src, target, skill_id, flag);
	}
	if( HPMHooks.count.HP_status_check_skilluse_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, uint16 skill_id, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_skilluse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_check_skilluse_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, skill_id, flag);
		}
	}
	return retVal___;
}
int HP_status_check_visibility(struct block_list *src, struct block_list *target) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.check_visibility(src, target);
	}
	if( HPMHooks.count.HP_status_check_visibility_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_check_visibility_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_check_visibility_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target);
		}
	}
	return retVal___;
}
int HP_status_change_spread(struct block_list *src, struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.change_spread(src, bl);
	}
	if( HPMHooks.count.HP_status_change_spread_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_change_spread_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_change_spread_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, bl);
		}
	}
	return retVal___;
}
defType HP_status_calc_def(struct block_list *bl, struct status_change *sc, int def, bool viewable) {
	int hIndex = 0;
	defType retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_def(bl, sc, def, viewable);
	}
	if( HPMHooks.count.HP_status_calc_def_post ) {
		defType (*postHookFunc) (defType retVal___, struct block_list *bl, struct status_change *sc, int def, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_def_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, def, viewable);
		}
	}
	return retVal___;
}
short HP_status_calc_def2(struct block_list *bl, struct status_change *sc, int def2, bool viewable) {
	int hIndex = 0;
	short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_def2(bl, sc, def2, viewable);
	}
	if( HPMHooks.count.HP_status_calc_def2_post ) {
		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int def2, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_def2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_def2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, def2, viewable);
		}
	}
	return retVal___;
}
defType HP_status_calc_mdef(struct block_list *bl, struct status_change *sc, int mdef, bool viewable) {
	int hIndex = 0;
	defType retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_mdef(bl, sc, mdef, viewable);
	}
	if( HPMHooks.count.HP_status_calc_mdef_post ) {
		defType (*postHookFunc) (defType retVal___, struct block_list *bl, struct status_change *sc, int mdef, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_mdef_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, mdef, viewable);
		}
	}
	return retVal___;
}
short HP_status_calc_mdef2(struct block_list *bl, struct status_change *sc, int mdef2, bool viewable) {
	int hIndex = 0;
	short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_mdef2(bl, sc, mdef2, viewable);
	}
	if( HPMHooks.count.HP_status_calc_mdef2_post ) {
		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int mdef2, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mdef2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_mdef2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, mdef2, viewable);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_batk(struct block_list *bl, struct status_change *sc, int batk, bool viewable) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_batk(bl, sc, batk, viewable);
	}
	if( HPMHooks.count.HP_status_calc_batk_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int batk, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_batk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_batk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, batk, viewable);
		}
	}
	return retVal___;
}
unsigned short HP_status_base_matk(struct block_list *bl, const struct status_data *st, int level) {
	int hIndex = 0;
	unsigned short retVal___ = 0;
	if( HPMHooks.count.HP_status_base_matk_pre ) {
		unsigned short (*preHookFunc) (struct block_list **bl, 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(&bl, &st, &level);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.base_matk(bl, st, level);
	}
	if( HPMHooks.count.HP_status_base_matk_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, const struct status_data *st, int level);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_base_matk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, st, level);
		}
	}
	return retVal___;
}
int HP_status_get_weapon_atk(struct block_list *src, struct weapon_atk *watk, int flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_weapon_atk(src, watk, flag);
	}
	if( HPMHooks.count.HP_status_get_weapon_atk_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct weapon_atk *watk, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_weapon_atk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_weapon_atk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, watk, flag);
		}
	}
	return retVal___;
}
int HP_status_get_total_mdef(struct block_list *src) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_total_mdef(src);
	}
	if( HPMHooks.count.HP_status_get_total_mdef_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_total_mdef_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_total_mdef_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src);
		}
	}
	return retVal___;
}
int HP_status_get_total_def(struct block_list *src) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_total_def(src);
	}
	if( HPMHooks.count.HP_status_get_total_def_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_total_def_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_total_def_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src);
		}
	}
	return retVal___;
}
int HP_status_get_matk(struct block_list *src, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_matk(src, flag);
	}
	if( HPMHooks.count.HP_status_get_matk_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_matk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_matk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, flag);
		}
	}
	return retVal___;
}
void HP_status_update_matk(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_update_matk_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_update_matk_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_update_matk_pre[hIndex].func;
			preHookFunc(&bl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.update_matk(bl);
	}
	if( HPMHooks.count.HP_status_update_matk_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_update_matk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_update_matk_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
int HP_status_readdb(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.readdb();
	}
	if( HPMHooks.count.HP_status_readdb_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_readdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_status_initChangeTables(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_initChangeTables_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initChangeTables_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_initChangeTables_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.initChangeTables();
	}
	if( HPMHooks.count.HP_status_initChangeTables_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initChangeTables_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_initChangeTables_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_status_initDummyData(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_initDummyData_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initDummyData_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_initDummyData_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.initDummyData();
	}
	if( HPMHooks.count.HP_status_initDummyData_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_initDummyData_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_initDummyData_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_status_base_amotion_pc(struct map_session_data *sd, struct status_data *st) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.base_amotion_pc(sd, st);
	}
	if( HPMHooks.count.HP_status_base_amotion_pc_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct status_data *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_amotion_pc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_base_amotion_pc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, st);
		}
	}
	return retVal___;
}
unsigned short HP_status_base_atk(const struct block_list *bl, const struct status_data *st) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.base_atk(bl, st);
	}
	if( HPMHooks.count.HP_status_base_atk_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, const struct block_list *bl, const struct status_data *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_atk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_base_atk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, st);
		}
	}
	return retVal___;
}
unsigned int HP_status_get_base_maxhp(const struct map_session_data *sd, const struct status_data *st) {
	int hIndex = 0;
	unsigned int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_base_maxhp_pre ) {
		unsigned int (*preHookFunc) (const struct map_session_data **sd, const struct status_data **st);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_maxhp_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_get_base_maxhp_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &st);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_base_maxhp(sd, st);
	}
	if( HPMHooks.count.HP_status_get_base_maxhp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, const struct map_session_data *sd, const struct status_data *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_maxhp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_base_maxhp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, st);
		}
	}
	return retVal___;
}
unsigned int HP_status_get_base_maxsp(const struct map_session_data *sd, const struct status_data *st) {
	int hIndex = 0;
	unsigned int retVal___ = 0;
	if( HPMHooks.count.HP_status_get_base_maxsp_pre ) {
		unsigned int (*preHookFunc) (const struct map_session_data **sd, const struct status_data **st);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_maxsp_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_get_base_maxsp_pre[hIndex].func;
			retVal___ = preHookFunc(&sd, &st);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.get_base_maxsp(sd, st);
	}
	if( HPMHooks.count.HP_status_get_base_maxsp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, const struct map_session_data *sd, const struct status_data *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_get_base_maxsp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_get_base_maxsp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, st);
		}
	}
	return retVal___;
}
int HP_status_calc_npc_(struct npc_data *nd, enum e_status_calc_opt opt) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_npc_(nd, opt);
	}
	if( HPMHooks.count.HP_status_calc_npc__post ) {
		int (*postHookFunc) (int retVal___, struct npc_data *nd, enum e_status_calc_opt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_npc__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_npc__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, nd, opt);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_str(struct block_list *bl, struct status_change *sc, int str) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_str(bl, sc, str);
	}
	if( HPMHooks.count.HP_status_calc_str_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_str_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_str_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, str);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_agi(struct block_list *bl, struct status_change *sc, int agi) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_agi(bl, sc, agi);
	}
	if( HPMHooks.count.HP_status_calc_agi_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int agi);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_agi_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_agi_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, agi);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_vit(struct block_list *bl, struct status_change *sc, int vit) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_vit(bl, sc, vit);
	}
	if( HPMHooks.count.HP_status_calc_vit_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int vit);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_vit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_vit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, vit);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_int(struct block_list *bl, struct status_change *sc, int int_) {
	int hIndex = 0;
	unsigned short retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_int(bl, sc, int_);
	}
	if( HPMHooks.count.HP_status_calc_int_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int int_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_int_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_int_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, int_);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_dex(struct block_list *bl, struct status_change *sc, int dex) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_dex(bl, sc, dex);
	}
	if( HPMHooks.count.HP_status_calc_dex_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int dex);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dex_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_dex_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, dex);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_luk(struct block_list *bl, struct status_change *sc, int luk) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_luk(bl, sc, luk);
	}
	if( HPMHooks.count.HP_status_calc_luk_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int luk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_luk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_luk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, luk);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_watk(struct block_list *bl, struct status_change *sc, int watk, bool viewable) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_watk(bl, sc, watk, viewable);
	}
	if( HPMHooks.count.HP_status_calc_watk_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int watk, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_watk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_watk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, watk, viewable);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_matk(struct block_list *bl, struct status_change *sc, int matk, bool viewable) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_matk(bl, sc, matk, viewable);
	}
	if( HPMHooks.count.HP_status_calc_matk_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int matk, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_matk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_matk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, matk, viewable);
		}
	}
	return retVal___;
}
signed short HP_status_calc_hit(struct block_list *bl, struct status_change *sc, int hit, bool viewable) {
	int hIndex = 0;
	signed short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_hit(bl, sc, hit, viewable);
	}
	if( HPMHooks.count.HP_status_calc_hit_post ) {
		signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int hit, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_hit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_hit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, hit, viewable);
		}
	}
	return retVal___;
}
signed short HP_status_calc_critical(struct block_list *bl, struct status_change *sc, int critical, bool viewable) {
	int hIndex = 0;
	signed short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_critical(bl, sc, critical, viewable);
	}
	if( HPMHooks.count.HP_status_calc_critical_post ) {
		signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int critical, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_critical_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_critical_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, critical, viewable);
		}
	}
	return retVal___;
}
signed short HP_status_calc_flee(struct block_list *bl, struct status_change *sc, int flee, bool viewable) {
	int hIndex = 0;
	signed short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_flee(bl, sc, flee, viewable);
	}
	if( HPMHooks.count.HP_status_calc_flee_post ) {
		signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int flee, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_flee_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, flee, viewable);
		}
	}
	return retVal___;
}
signed short HP_status_calc_flee2(struct block_list *bl, struct status_change *sc, int flee2, bool viewable) {
	int hIndex = 0;
	signed short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_flee2(bl, sc, flee2, viewable);
	}
	if( HPMHooks.count.HP_status_calc_flee2_post ) {
		signed short (*postHookFunc) (signed short retVal___, struct block_list *bl, struct status_change *sc, int flee2, bool viewable);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_flee2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_flee2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, flee2, viewable);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_speed(struct block_list *bl, struct status_change *sc, int speed) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_speed(bl, sc, speed);
	}
	if( HPMHooks.count.HP_status_calc_speed_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int speed);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_speed_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_speed_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, speed);
		}
	}
	return retVal___;
}
short HP_status_calc_aspd_rate(struct block_list *bl, struct status_change *sc, int aspd_rate) {
	int hIndex = 0;
	short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_aspd_rate(bl, sc, aspd_rate);
	}
	if( HPMHooks.count.HP_status_calc_aspd_rate_post ) {
		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int aspd_rate);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_rate_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_aspd_rate_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, aspd_rate);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_dmotion(struct block_list *bl, struct status_change *sc, int dmotion) {
	int hIndex = 0;
	unsigned short retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_dmotion(bl, sc, dmotion);
	}
	if( HPMHooks.count.HP_status_calc_dmotion_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int dmotion);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_dmotion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_dmotion_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, dmotion);
		}
	}
	return retVal___;
}
short HP_status_calc_aspd(struct block_list *bl, struct status_change *sc, short flag) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_aspd(bl, sc, flag);
	}
	if( HPMHooks.count.HP_status_calc_aspd_post ) {
		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, short flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_aspd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_aspd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, flag);
		}
	}
	return retVal___;
}
short HP_status_calc_fix_aspd(struct block_list *bl, struct status_change *sc, int aspd) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_fix_aspd(bl, sc, aspd);
	}
	if( HPMHooks.count.HP_status_calc_fix_aspd_post ) {
		short (*postHookFunc) (short retVal___, struct block_list *bl, struct status_change *sc, int aspd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_fix_aspd_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_fix_aspd_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, aspd);
		}
	}
	return retVal___;
}
unsigned int HP_status_calc_maxhp(struct block_list *bl, struct status_change *sc, uint64 maxhp) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_maxhp(bl, sc, maxhp);
	}
	if( HPMHooks.count.HP_status_calc_maxhp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, uint64 maxhp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxhp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_maxhp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, maxhp);
		}
	}
	return retVal___;
}
unsigned int HP_status_calc_maxsp(struct block_list *bl, struct status_change *sc, unsigned int maxsp) {
	int hIndex = 0;
	unsigned int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_maxsp(bl, sc, maxsp);
	}
	if( HPMHooks.count.HP_status_calc_maxsp_post ) {
		unsigned int (*postHookFunc) (unsigned int retVal___, struct block_list *bl, struct status_change *sc, unsigned int maxsp);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_maxsp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_maxsp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, maxsp);
		}
	}
	return retVal___;
}
unsigned char HP_status_calc_element(struct block_list *bl, struct status_change *sc, int element) {
	int hIndex = 0;
	unsigned char retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_element(bl, sc, element);
	}
	if( HPMHooks.count.HP_status_calc_element_post ) {
		unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int element);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_element_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, element);
		}
	}
	return retVal___;
}
unsigned char HP_status_calc_element_lv(struct block_list *bl, struct status_change *sc, int lv) {
	int hIndex = 0;
	unsigned char retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_element_lv(bl, sc, lv);
	}
	if( HPMHooks.count.HP_status_calc_element_lv_post ) {
		unsigned char (*postHookFunc) (unsigned char retVal___, struct block_list *bl, struct status_change *sc, int lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_element_lv_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_element_lv_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, lv);
		}
	}
	return retVal___;
}
uint32 HP_status_calc_mode(const struct block_list *bl, const struct status_change *sc, uint32 mode) {
	int hIndex = 0;
	uint32 retVal___ = 0;
	if( HPMHooks.count.HP_status_calc_mode_pre ) {
		uint32 (*preHookFunc) (const struct block_list **bl, const struct status_change **sc, uint32 *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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_mode(bl, sc, mode);
	}
	if( HPMHooks.count.HP_status_calc_mode_post ) {
		uint32 (*postHookFunc) (uint32 retVal___, const struct block_list *bl, const struct status_change *sc, uint32 mode);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_mode_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_mode_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, mode);
		}
	}
	return retVal___;
}
unsigned short HP_status_calc_ematk(struct block_list *bl, struct status_change *sc, int matk) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.calc_ematk(bl, sc, matk);
	}
	if( HPMHooks.count.HP_status_calc_ematk_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, struct block_list *bl, struct status_change *sc, int matk);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_ematk_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_ematk_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sc, matk);
		}
	}
	return retVal___;
}
void HP_status_calc_bl_main(struct block_list *bl, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_calc_bl_main_pre ) {
		void (*preHookFunc) (struct block_list **bl, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.calc_bl_main(bl, flag);
	}
	if( HPMHooks.count.HP_status_calc_bl_main_post ) {
		void (*postHookFunc) (struct block_list *bl, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_calc_bl_main_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_calc_bl_main_post[hIndex].func;
			postHookFunc(bl, flag);
		}
	}
	return;
}
void HP_status_display_add(struct map_session_data *sd, enum sc_type type, int dval1, int dval2, int dval3) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_display_add_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum sc_type *type, int *dval1, int *dval2, int *dval3);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.display_add(sd, type, dval1, dval2, dval3);
	}
	if( HPMHooks.count.HP_status_display_add_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum sc_type type, int dval1, int dval2, int dval3);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_display_add_post[hIndex].func;
			postHookFunc(sd, type, dval1, dval2, dval3);
		}
	}
	return;
}
void HP_status_display_remove(struct map_session_data *sd, enum sc_type type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_display_remove_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, enum sc_type *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.display_remove(sd, type);
	}
	if( HPMHooks.count.HP_status_display_remove_post ) {
		void (*postHookFunc) (struct map_session_data *sd, enum sc_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_display_remove_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_display_remove_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
int HP_status_natural_heal(struct block_list *bl, va_list args) {
	int hIndex = 0;
	int retVal___ = 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;
			retVal___ = preHookFunc(&bl, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.status.natural_heal(bl, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_status_natural_heal_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_natural_heal_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_status_natural_heal_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_status_natural_heal_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.natural_heal_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_status_natural_heal_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_natural_heal_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_natural_heal_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
bool HP_status_readdb_job2(char *fields[], int columns, int current) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.readdb_job2(fields, columns, current);
	}
	if( HPMHooks.count.HP_status_readdb_job2_post ) {
		bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_job2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_readdb_job2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fields, columns, current);
		}
	}
	return retVal___;
}
bool HP_status_readdb_sizefix(char *fields[], int columns, int current) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.readdb_sizefix(fields, columns, current);
	}
	if( HPMHooks.count.HP_status_readdb_sizefix_post ) {
		bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_sizefix_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_readdb_sizefix_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fields, columns, current);
		}
	}
	return retVal___;
}
int HP_status_readdb_refine_libconfig(const char *filename) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_readdb_refine_libconfig_pre ) {
		int (*preHookFunc) (const char **filename);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_refine_libconfig_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_readdb_refine_libconfig_pre[hIndex].func;
			retVal___ = preHookFunc(&filename);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.readdb_refine_libconfig(filename);
	}
	if( HPMHooks.count.HP_status_readdb_refine_libconfig_post ) {
		int (*postHookFunc) (int retVal___, const char *filename);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_refine_libconfig_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_readdb_refine_libconfig_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, filename);
		}
	}
	return retVal___;
}
int HP_status_readdb_refine_libconfig_sub(struct config_setting_t *r, const char *name, const char *source) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_status_readdb_refine_libconfig_sub_pre ) {
		int (*preHookFunc) (struct config_setting_t **r, const char **name, const char **source);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_refine_libconfig_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_readdb_refine_libconfig_sub_pre[hIndex].func;
			retVal___ = preHookFunc(&r, &name, &source);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.readdb_refine_libconfig_sub(r, name, source);
	}
	if( HPMHooks.count.HP_status_readdb_refine_libconfig_sub_post ) {
		int (*postHookFunc) (int retVal___, struct config_setting_t *r, const char *name, const char *source);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_refine_libconfig_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_readdb_refine_libconfig_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, r, name, source);
		}
	}
	return retVal___;
}
bool HP_status_readdb_scconfig(char *fields[], int columns, int current) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.readdb_scconfig(fields, columns, current);
	}
	if( HPMHooks.count.HP_status_readdb_scconfig_post ) {
		bool (*postHookFunc) (bool retVal___, char *fields[], int columns, int current);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_readdb_scconfig_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_readdb_scconfig_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, fields, columns, current);
		}
	}
	return retVal___;
}
void HP_status_read_job_db(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_read_job_db_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_read_job_db_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_read_job_db_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.read_job_db();
	}
	if( HPMHooks.count.HP_status_read_job_db_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_read_job_db_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_read_job_db_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_status_read_job_db_sub(int idx, const char *name, struct config_setting_t *jdb) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_read_job_db_sub_pre ) {
		void (*preHookFunc) (int *idx, const char **name, struct config_setting_t **jdb);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_read_job_db_sub_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_read_job_db_sub_pre[hIndex].func;
			preHookFunc(&idx, &name, &jdb);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.read_job_db_sub(idx, name, jdb);
	}
	if( HPMHooks.count.HP_status_read_job_db_sub_post ) {
		void (*postHookFunc) (int idx, const char *name, struct config_setting_t *jdb);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_read_job_db_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_read_job_db_sub_post[hIndex].func;
			postHookFunc(idx, name, jdb);
		}
	}
	return;
}
void HP_status_set_sc(uint16 skill_id, sc_type sc, int icon, unsigned int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_set_sc_pre ) {
		void (*preHookFunc) (uint16 *skill_id, sc_type *sc, int *icon, unsigned int *flag);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_set_sc_pre[hIndex].func;
			preHookFunc(&skill_id, &sc, &icon, &flag);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.set_sc(skill_id, sc, icon, flag);
	}
	if( HPMHooks.count.HP_status_set_sc_post ) {
		void (*postHookFunc) (uint16 skill_id, sc_type sc, int icon, unsigned int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_set_sc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_set_sc_post[hIndex].func;
			postHookFunc(skill_id, sc, icon, flag);
		}
	}
	return;
}
void HP_status_copy(struct status_data *a, const struct status_data *b) {
	int hIndex = 0;
	if( HPMHooks.count.HP_status_copy_pre ) {
		void (*preHookFunc) (struct status_data **a, const struct status_data **b);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_copy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_copy_pre[hIndex].func;
			preHookFunc(&a, &b);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.status.copy(a, b);
	}
	if( HPMHooks.count.HP_status_copy_post ) {
		void (*postHookFunc) (struct status_data *a, const struct status_data *b);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_copy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_copy_post[hIndex].func;
			postHookFunc(a, b);
		}
	}
	return;
}
unsigned short HP_status_base_matk_min(const struct status_data *st) {
	int hIndex = 0;
	unsigned short retVal___ = 0;
	if( HPMHooks.count.HP_status_base_matk_min_pre ) {
		unsigned short (*preHookFunc) (const struct status_data **st);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_min_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_base_matk_min_pre[hIndex].func;
			retVal___ = preHookFunc(&st);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.base_matk_min(st);
	}
	if( HPMHooks.count.HP_status_base_matk_min_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, const struct status_data *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_min_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_base_matk_min_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st);
		}
	}
	return retVal___;
}
unsigned short HP_status_base_matk_max(const struct status_data *st) {
	int hIndex = 0;
	unsigned short retVal___ = 0;
	if( HPMHooks.count.HP_status_base_matk_max_pre ) {
		unsigned short (*preHookFunc) (const struct status_data **st);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_max_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_status_base_matk_max_pre[hIndex].func;
			retVal___ = preHookFunc(&st);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.status.base_matk_max(st);
	}
	if( HPMHooks.count.HP_status_base_matk_max_post ) {
		unsigned short (*postHookFunc) (unsigned short retVal___, const struct status_data *st);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_status_base_matk_max_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_status_base_matk_max_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, st);
		}
	}
	return retVal___;
}
/* storage_interface */
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.storage.reconnect();
	}
	if( HPMHooks.count.HP_storage_reconnect_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_reconnect_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
int HP_storage_delitem(struct map_session_data *sd, int n, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.storage.delitem(sd, n, amount);
	}
	if( HPMHooks.count.HP_storage_delitem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int n, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_delitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_delitem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, n, amount);
		}
	}
	return retVal___;
}
int HP_storage_open(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.storage.open(sd);
	}
	if( HPMHooks.count.HP_storage_open_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_open_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_storage_add(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.storage.add(sd, index, amount);
	}
	if( HPMHooks.count.HP_storage_add_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_add_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index, amount);
		}
	}
	return retVal___;
}
int HP_storage_get(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.storage.get(sd, index, amount);
	}
	if( HPMHooks.count.HP_storage_get_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_get_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_get_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index, amount);
		}
	}
	return retVal___;
}
int HP_storage_additem(struct map_session_data *sd, struct item *item_data, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.storage.additem(sd, item_data, amount);
	}
	if( HPMHooks.count.HP_storage_additem_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct item *item_data, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_additem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_additem_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, item_data, amount);
		}
	}
	return retVal___;
}
int HP_storage_addfromcart(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.storage.addfromcart(sd, index, amount);
	}
	if( HPMHooks.count.HP_storage_addfromcart_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_addfromcart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_addfromcart_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index, amount);
		}
	}
	return retVal___;
}
int HP_storage_gettocart(struct map_session_data *sd, int index, int amount) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.storage.gettocart(sd, index, amount);
	}
	if( HPMHooks.count.HP_storage_gettocart_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, int index, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_gettocart_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_gettocart_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, index, amount);
		}
	}
	return retVal___;
}
void HP_storage_close(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_storage_close_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.storage.close(sd);
	}
	if( HPMHooks.count.HP_storage_close_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_close_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_storage_pc_quit(struct map_session_data *sd, int flag) {
	int hIndex = 0;
	if( HPMHooks.count.HP_storage_pc_quit_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *flag);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.storage.pc_quit(sd, flag);
	}
	if( HPMHooks.count.HP_storage_pc_quit_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_pc_quit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_pc_quit_post[hIndex].func;
			postHookFunc(sd, flag);
		}
	}
	return;
}
int HP_storage_comp_item(const void *i1_, const void *i2_) {
	int hIndex = 0;
	int retVal___ = 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_);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.storage.comp_item(i1_, i2_);
	}
	if( HPMHooks.count.HP_storage_comp_item_post ) {
		int (*postHookFunc) (int retVal___, const void *i1_, const void *i2_);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_comp_item_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_comp_item_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, i1_, i2_);
		}
	}
	return retVal___;
}
void HP_storage_sortitem(struct item *items, unsigned int size) {
	int hIndex = 0;
	if( HPMHooks.count.HP_storage_sortitem_pre ) {
		void (*preHookFunc) (struct item **items, unsigned int *size);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.storage.sortitem(items, size);
	}
	if( HPMHooks.count.HP_storage_sortitem_post ) {
		void (*postHookFunc) (struct item *items, unsigned int size);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_sortitem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_storage_sortitem_post[hIndex].func;
			postHookFunc(items, size);
		}
	}
	return;
}
int HP_storage_reconnect_sub(union DBKey key, struct DBData *data, va_list ap) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_storage_reconnect_sub_pre ) {
		int (*preHookFunc) (union DBKey *key, struct 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;
			retVal___ = preHookFunc(&key, &data, ap___copy);
			va_end(ap___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list ap___copy; va_copy(ap___copy, ap);
		retVal___ = HPMHooks.source.storage.reconnect_sub(key, data, ap___copy);
		va_end(ap___copy);
	}
	if( HPMHooks.count.HP_storage_reconnect_sub_post ) {
		int (*postHookFunc) (int retVal___, union DBKey key, struct DBData *data, va_list ap);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_storage_reconnect_sub_post; hIndex++ ) {
			va_list ap___copy; va_copy(ap___copy, ap);
			postHookFunc = HPMHooks.list.HP_storage_reconnect_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, key, data, ap___copy);
			va_end(ap___copy);
		}
	}
	return retVal___;
}
/* stringbuf_interface */
StringBuf* HP_StrBuf_Malloc(void) {
	int hIndex = 0;
	StringBuf* retVal___ = NULL;
	if( HPMHooks.count.HP_StrBuf_Malloc_pre ) {
		StringBuf* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Malloc_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_Malloc_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.StrBuf.Malloc();
	}
	if( HPMHooks.count.HP_StrBuf_Malloc_post ) {
		StringBuf* (*postHookFunc) (StringBuf* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Malloc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_Malloc_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_StrBuf_Init(StringBuf *self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_StrBuf_Init_pre ) {
		void (*preHookFunc) (StringBuf **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_Init_pre[hIndex].func;
			preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.StrBuf.Init(self);
	}
	if( HPMHooks.count.HP_StrBuf_Init_post ) {
		void (*postHookFunc) (StringBuf *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_Init_post[hIndex].func;
			postHookFunc(self);
		}
	}
	return;
}
int HP_StrBuf_Vprintf(StringBuf *self, const char *fmt, va_list args) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_StrBuf_Vprintf_pre ) {
		int (*preHookFunc) (StringBuf **self, const char **fmt, va_list args);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_pre; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			preHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &fmt, args___copy);
			va_end(args___copy);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		va_list args___copy; va_copy(args___copy, args);
		retVal___ = HPMHooks.source.StrBuf.Vprintf(self, fmt, args___copy);
		va_end(args___copy);
	}
	if( HPMHooks.count.HP_StrBuf_Vprintf_post ) {
		int (*postHookFunc) (int retVal___, StringBuf *self, const char *fmt, va_list args);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Vprintf_post; hIndex++ ) {
			va_list args___copy; va_copy(args___copy, args);
			postHookFunc = HPMHooks.list.HP_StrBuf_Vprintf_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, fmt, args___copy);
			va_end(args___copy);
		}
	}
	return retVal___;
}
int HP_StrBuf_Append(StringBuf *self, const StringBuf *sbuf) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_StrBuf_Append_pre ) {
		int (*preHookFunc) (StringBuf **self, const StringBuf **sbuf);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_Append_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &sbuf);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.StrBuf.Append(self, sbuf);
	}
	if( HPMHooks.count.HP_StrBuf_Append_post ) {
		int (*postHookFunc) (int retVal___, StringBuf *self, const StringBuf *sbuf);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Append_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_Append_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, sbuf);
		}
	}
	return retVal___;
}
int HP_StrBuf_AppendStr(StringBuf *self, const char *str) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_StrBuf_AppendStr_pre ) {
		int (*preHookFunc) (StringBuf **self, const char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_pre[hIndex].func;
			retVal___ = preHookFunc(&self, &str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.StrBuf.AppendStr(self, str);
	}
	if( HPMHooks.count.HP_StrBuf_AppendStr_post ) {
		int (*postHookFunc) (int retVal___, StringBuf *self, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_AppendStr_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_AppendStr_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self, str);
		}
	}
	return retVal___;
}
int HP_StrBuf_Length(StringBuf *self) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_StrBuf_Length_pre ) {
		int (*preHookFunc) (StringBuf **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_Length_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.StrBuf.Length(self);
	}
	if( HPMHooks.count.HP_StrBuf_Length_post ) {
		int (*postHookFunc) (int retVal___, StringBuf *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Length_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_Length_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
char* HP_StrBuf_Value(StringBuf *self) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_StrBuf_Value_pre ) {
		char* (*preHookFunc) (StringBuf **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_Value_pre[hIndex].func;
			retVal___ = preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.StrBuf.Value(self);
	}
	if( HPMHooks.count.HP_StrBuf_Value_post ) {
		char* (*postHookFunc) (char* retVal___, StringBuf *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Value_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_Value_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, self);
		}
	}
	return retVal___;
}
void HP_StrBuf_Clear(StringBuf *self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_StrBuf_Clear_pre ) {
		void (*preHookFunc) (StringBuf **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_Clear_pre[hIndex].func;
			preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.StrBuf.Clear(self);
	}
	if( HPMHooks.count.HP_StrBuf_Clear_post ) {
		void (*postHookFunc) (StringBuf *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Clear_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_Clear_post[hIndex].func;
			postHookFunc(self);
		}
	}
	return;
}
void HP_StrBuf_Destroy(StringBuf *self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_StrBuf_Destroy_pre ) {
		void (*preHookFunc) (StringBuf **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_Destroy_pre[hIndex].func;
			preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.StrBuf.Destroy(self);
	}
	if( HPMHooks.count.HP_StrBuf_Destroy_post ) {
		void (*postHookFunc) (StringBuf *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Destroy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_Destroy_post[hIndex].func;
			postHookFunc(self);
		}
	}
	return;
}
void HP_StrBuf_Free(StringBuf *self) {
	int hIndex = 0;
	if( HPMHooks.count.HP_StrBuf_Free_pre ) {
		void (*preHookFunc) (StringBuf **self);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_StrBuf_Free_pre[hIndex].func;
			preHookFunc(&self);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.StrBuf.Free(self);
	}
	if( HPMHooks.count.HP_StrBuf_Free_post ) {
		void (*postHookFunc) (StringBuf *self);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_StrBuf_Free_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_StrBuf_Free_post[hIndex].func;
			postHookFunc(self);
		}
	}
	return;
}
/* strlib_interface */
char* HP_strlib_jstrescape(char *pt) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_strlib_jstrescape_pre ) {
		char* (*preHookFunc) (char **pt);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_jstrescape_pre[hIndex].func;
			retVal___ = preHookFunc(&pt);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.jstrescape(pt);
	}
	if( HPMHooks.count.HP_strlib_jstrescape_post ) {
		char* (*postHookFunc) (char* retVal___, char *pt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescape_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_jstrescape_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pt);
		}
	}
	return retVal___;
}
char* HP_strlib_jstrescapecpy(char *pt, const char *spt) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_strlib_jstrescapecpy_pre ) {
		char* (*preHookFunc) (char **pt, const char **spt);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_pre[hIndex].func;
			retVal___ = preHookFunc(&pt, &spt);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.jstrescapecpy(pt, spt);
	}
	if( HPMHooks.count.HP_strlib_jstrescapecpy_post ) {
		char* (*postHookFunc) (char* retVal___, char *pt, const char *spt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jstrescapecpy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_jstrescapecpy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pt, spt);
		}
	}
	return retVal___;
}
int HP_strlib_jmemescapecpy(char *pt, const char *spt, int size) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_strlib_jmemescapecpy_pre ) {
		int (*preHookFunc) (char **pt, const char **spt, int *size);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_pre[hIndex].func;
			retVal___ = preHookFunc(&pt, &spt, &size);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.jmemescapecpy(pt, spt, size);
	}
	if( HPMHooks.count.HP_strlib_jmemescapecpy_post ) {
		int (*postHookFunc) (int retVal___, char *pt, const char *spt, int size);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_jmemescapecpy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_jmemescapecpy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, pt, spt, size);
		}
	}
	return retVal___;
}
int HP_strlib_remove_control_chars_(char *str) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_strlib_remove_control_chars__pre ) {
		int (*preHookFunc) (char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__pre[hIndex].func;
			retVal___ = preHookFunc(&str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.remove_control_chars_(str);
	}
	if( HPMHooks.count.HP_strlib_remove_control_chars__post ) {
		int (*postHookFunc) (int retVal___, char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_remove_control_chars__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_remove_control_chars__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
char* HP_strlib_trim_(char *str) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_strlib_trim__pre ) {
		char* (*preHookFunc) (char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_trim__pre[hIndex].func;
			retVal___ = preHookFunc(&str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.trim_(str);
	}
	if( HPMHooks.count.HP_strlib_trim__post ) {
		char* (*postHookFunc) (char* retVal___, char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_trim__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_trim__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
char* HP_strlib_normalize_name_(char *str, const char *delims) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_strlib_normalize_name__pre ) {
		char* (*preHookFunc) (char **str, const char **delims);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_normalize_name__pre[hIndex].func;
			retVal___ = preHookFunc(&str, &delims);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.normalize_name_(str, delims);
	}
	if( HPMHooks.count.HP_strlib_normalize_name__post ) {
		char* (*postHookFunc) (char* retVal___, char *str, const char *delims);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_normalize_name__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_normalize_name__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, delims);
		}
	}
	return retVal___;
}
const char* HP_strlib_stristr_(const char *haystack, const char *needle) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_strlib_stristr__pre ) {
		const char* (*preHookFunc) (const char **haystack, const char **needle);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_stristr__pre[hIndex].func;
			retVal___ = preHookFunc(&haystack, &needle);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.stristr_(haystack, needle);
	}
	if( HPMHooks.count.HP_strlib_stristr__post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *haystack, const char *needle);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_stristr__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_stristr__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, haystack, needle);
		}
	}
	return retVal___;
}
size_t HP_strlib_strnlen_(const char *string, size_t maxlen) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_strlib_strnlen__pre ) {
		size_t (*preHookFunc) (const char **string, size_t *maxlen);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_strnlen__pre[hIndex].func;
			retVal___ = preHookFunc(&string, &maxlen);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.strnlen_(string, maxlen);
	}
	if( HPMHooks.count.HP_strlib_strnlen__post ) {
		size_t (*postHookFunc) (size_t retVal___, const char *string, size_t maxlen);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strnlen__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_strnlen__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, string, maxlen);
		}
	}
	return retVal___;
}
char* HP_strlib_strtok_r_(char *s1, const char *s2, char **lasts) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_strlib_strtok_r__pre ) {
		char* (*preHookFunc) (char **s1, const char **s2, char ***lasts);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_strtok_r__pre[hIndex].func;
			retVal___ = preHookFunc(&s1, &s2, &lasts);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.strtok_r_(s1, s2, lasts);
	}
	if( HPMHooks.count.HP_strlib_strtok_r__post ) {
		char* (*postHookFunc) (char* retVal___, char *s1, const char *s2, char **lasts);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strtok_r__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_strtok_r__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, s1, s2, lasts);
		}
	}
	return retVal___;
}
int HP_strlib_e_mail_check_(char *email) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_strlib_e_mail_check__pre ) {
		int (*preHookFunc) (char **email);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_e_mail_check__pre[hIndex].func;
			retVal___ = preHookFunc(&email);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.e_mail_check_(email);
	}
	if( HPMHooks.count.HP_strlib_e_mail_check__post ) {
		int (*postHookFunc) (int retVal___, char *email);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_e_mail_check__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_e_mail_check__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, email);
		}
	}
	return retVal___;
}
int HP_strlib_config_switch_(const char *str) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_strlib_config_switch__pre ) {
		int (*preHookFunc) (const char **str);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_config_switch__pre[hIndex].func;
			retVal___ = preHookFunc(&str);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.config_switch_(str);
	}
	if( HPMHooks.count.HP_strlib_config_switch__post ) {
		int (*postHookFunc) (int retVal___, const char *str);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_config_switch__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_config_switch__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str);
		}
	}
	return retVal___;
}
char* HP_strlib_safestrncpy_(char *dst, const char *src, size_t n) {
	int hIndex = 0;
	char* retVal___ = NULL;
	if( HPMHooks.count.HP_strlib_safestrncpy__pre ) {
		char* (*preHookFunc) (char **dst, const char **src, size_t *n);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_safestrncpy__pre[hIndex].func;
			retVal___ = preHookFunc(&dst, &src, &n);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.safestrncpy_(dst, src, n);
	}
	if( HPMHooks.count.HP_strlib_safestrncpy__post ) {
		char* (*postHookFunc) (char* retVal___, char *dst, const char *src, size_t n);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrncpy__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_safestrncpy__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, dst, src, n);
		}
	}
	return retVal___;
}
size_t HP_strlib_safestrnlen_(const char *string, size_t maxlen) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_strlib_safestrnlen__pre ) {
		size_t (*preHookFunc) (const char **string, size_t *maxlen);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_safestrnlen__pre[hIndex].func;
			retVal___ = preHookFunc(&string, &maxlen);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.safestrnlen_(string, maxlen);
	}
	if( HPMHooks.count.HP_strlib_safestrnlen__post ) {
		size_t (*postHookFunc) (size_t retVal___, const char *string, size_t maxlen);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_safestrnlen__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_safestrnlen__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, string, maxlen);
		}
	}
	return retVal___;
}
int HP_strlib_strline_(const char *str, size_t pos) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_strlib_strline__pre ) {
		int (*preHookFunc) (const char **str, size_t *pos);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_strline__pre[hIndex].func;
			retVal___ = preHookFunc(&str, &pos);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.strline_(str, pos);
	}
	if( HPMHooks.count.HP_strlib_strline__post ) {
		int (*postHookFunc) (int retVal___, const char *str, size_t pos);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_strline__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_strline__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, pos);
		}
	}
	return retVal___;
}
bool HP_strlib_bin2hex_(char *output, const unsigned char *input, size_t count) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_strlib_bin2hex__pre ) {
		bool (*preHookFunc) (char **output, const unsigned char **input, size_t *count);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_strlib_bin2hex__pre[hIndex].func;
			retVal___ = preHookFunc(&output, &input, &count);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.strlib.bin2hex_(output, input, count);
	}
	if( HPMHooks.count.HP_strlib_bin2hex__post ) {
		bool (*postHookFunc) (bool retVal___, char *output, const unsigned char *input, size_t count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_strlib_bin2hex__post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_strlib_bin2hex__post[hIndex].func;
			retVal___ = postHookFunc(retVal___, output, input, count);
		}
	}
	return retVal___;
}
/* sv_interface */
int HP_sv_parse_next(struct s_svstate *svstate) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sv_parse_next_pre ) {
		int (*preHookFunc) (struct s_svstate **svstate);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sv_parse_next_pre[hIndex].func;
			retVal___ = preHookFunc(&svstate);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sv.parse_next(svstate);
	}
	if( HPMHooks.count.HP_sv_parse_next_post ) {
		int (*postHookFunc) (int retVal___, struct s_svstate *svstate);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_next_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sv_parse_next_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, svstate);
		}
	}
	return retVal___;
}
int HP_sv_parse(const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sv_parse_pre ) {
		int (*preHookFunc) (const char **str, int *len, int *startoff, char *delim, int **out_pos, int *npos, enum e_svopt *opt);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sv_parse_pre[hIndex].func;
			retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_pos, &npos, &opt);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sv.parse(str, len, startoff, delim, out_pos, npos, opt);
	}
	if( HPMHooks.count.HP_sv_parse_post ) {
		int (*postHookFunc) (int retVal___, const char *str, int len, int startoff, char delim, int *out_pos, int npos, enum e_svopt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_parse_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sv_parse_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_pos, npos, opt);
		}
	}
	return retVal___;
}
int HP_sv_split(char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sv_split_pre ) {
		int (*preHookFunc) (char **str, int *len, int *startoff, char *delim, char ***out_fields, int *nfields, enum e_svopt *opt);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sv_split_pre[hIndex].func;
			retVal___ = preHookFunc(&str, &len, &startoff, &delim, &out_fields, &nfields, &opt);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sv.split(str, len, startoff, delim, out_fields, nfields, opt);
	}
	if( HPMHooks.count.HP_sv_split_post ) {
		int (*postHookFunc) (int retVal___, char *str, int len, int startoff, char delim, char **out_fields, int nfields, enum e_svopt opt);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_split_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sv_split_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, str, len, startoff, delim, out_fields, nfields, opt);
		}
	}
	return retVal___;
}
size_t HP_sv_escape_c(char *out_dest, const char *src, size_t len, const char *escapes) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_sv_escape_c_pre ) {
		size_t (*preHookFunc) (char **out_dest, const char **src, size_t *len, const char **escapes);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sv_escape_c_pre[hIndex].func;
			retVal___ = preHookFunc(&out_dest, &src, &len, &escapes);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sv.escape_c(out_dest, src, len, escapes);
	}
	if( HPMHooks.count.HP_sv_escape_c_post ) {
		size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t len, const char *escapes);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_escape_c_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sv_escape_c_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, out_dest, src, len, escapes);
		}
	}
	return retVal___;
}
size_t HP_sv_unescape_c(char *out_dest, const char *src, size_t len) {
	int hIndex = 0;
	size_t retVal___ = 0;
	if( HPMHooks.count.HP_sv_unescape_c_pre ) {
		size_t (*preHookFunc) (char **out_dest, const char **src, size_t *len);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sv_unescape_c_pre[hIndex].func;
			retVal___ = preHookFunc(&out_dest, &src, &len);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sv.unescape_c(out_dest, src, len);
	}
	if( HPMHooks.count.HP_sv_unescape_c_post ) {
		size_t (*postHookFunc) (size_t retVal___, char *out_dest, const char *src, size_t len);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_unescape_c_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sv_unescape_c_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, out_dest, src, len);
		}
	}
	return retVal___;
}
const char* HP_sv_skip_escaped_c(const char *p) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sv_skip_escaped_c_pre ) {
		const char* (*preHookFunc) (const char **p);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_pre[hIndex].func;
			retVal___ = preHookFunc(&p);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sv.skip_escaped_c(p);
	}
	if( HPMHooks.count.HP_sv_skip_escaped_c_post ) {
		const char* (*postHookFunc) (const char* retVal___, const char *p);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_skip_escaped_c_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sv_skip_escaped_c_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, p);
		}
	}
	return retVal___;
}
bool HP_sv_readdb(const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current)) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_sv_readdb_pre ) {
		bool (*preHookFunc) (const char **directory, const char **filename, char *delim, int *mincols, int *maxcols, int *maxrows, bool ( **parseproc ) (char *fields[], int columns, int current));
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sv_readdb_pre[hIndex].func;
			retVal___ = preHookFunc(&directory, &filename, &delim, &mincols, &maxcols, &maxrows, &parseproc);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sv.readdb(directory, filename, delim, mincols, maxcols, maxrows, parseproc);
	}
	if( HPMHooks.count.HP_sv_readdb_post ) {
		bool (*postHookFunc) (bool retVal___, const char *directory, const char *filename, char delim, int mincols, int maxcols, int maxrows, bool ( *parseproc ) (char *fields[], int columns, int current));
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sv_readdb_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sv_readdb_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, directory, filename, delim, mincols, maxcols, maxrows, parseproc);
		}
	}
	return retVal___;
}
/* sysinfo_interface */
int HP_sysinfo_getpagesize(void) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sysinfo_getpagesize_pre ) {
		int (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_getpagesize_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_getpagesize_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.getpagesize();
	}
	if( HPMHooks.count.HP_sysinfo_getpagesize_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_getpagesize_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_getpagesize_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_platform(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_platform_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_platform_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_platform_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.platform();
	}
	if( HPMHooks.count.HP_sysinfo_platform_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_platform_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_platform_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_osversion(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_osversion_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_osversion_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_osversion_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.osversion();
	}
	if( HPMHooks.count.HP_sysinfo_osversion_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_osversion_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_osversion_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_cpu(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_cpu_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpu_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_cpu_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.cpu();
	}
	if( HPMHooks.count.HP_sysinfo_cpu_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpu_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_cpu_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_sysinfo_cpucores(void) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sysinfo_cpucores_pre ) {
		int (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpucores_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_cpucores_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.cpucores();
	}
	if( HPMHooks.count.HP_sysinfo_cpucores_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cpucores_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_cpucores_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_arch(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_arch_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_arch_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_arch_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.arch();
	}
	if( HPMHooks.count.HP_sysinfo_arch_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_arch_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_arch_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_sysinfo_is64bit(void) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_sysinfo_is64bit_pre ) {
		bool (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is64bit_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_is64bit_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.is64bit();
	}
	if( HPMHooks.count.HP_sysinfo_is64bit_post ) {
		bool (*postHookFunc) (bool retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is64bit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_is64bit_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_compiler(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_compiler_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_compiler_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_compiler_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.compiler();
	}
	if( HPMHooks.count.HP_sysinfo_compiler_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_compiler_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_compiler_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_cflags(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_cflags_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cflags_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_cflags_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.cflags();
	}
	if( HPMHooks.count.HP_sysinfo_cflags_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_cflags_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_cflags_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_time(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_time_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_time_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_time_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.time();
	}
	if( HPMHooks.count.HP_sysinfo_time_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_time_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_time_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_vcstype(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_vcstype_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstype_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_vcstype_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.vcstype();
	}
	if( HPMHooks.count.HP_sysinfo_vcstype_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstype_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_vcstype_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_sysinfo_vcstypeid(void) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_sysinfo_vcstypeid_pre ) {
		int (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstypeid_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_vcstypeid_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.vcstypeid();
	}
	if( HPMHooks.count.HP_sysinfo_vcstypeid_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcstypeid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_vcstypeid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_vcsrevision_src(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_vcsrevision_src_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_src_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_src_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.vcsrevision_src();
	}
	if( HPMHooks.count.HP_sysinfo_vcsrevision_src_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_src_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_src_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
const char* HP_sysinfo_vcsrevision_scripts(void) {
	int hIndex = 0;
	const char* retVal___ = NULL;
	if( HPMHooks.count.HP_sysinfo_vcsrevision_scripts_pre ) {
		const char* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_scripts_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_scripts_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.vcsrevision_scripts();
	}
	if( HPMHooks.count.HP_sysinfo_vcsrevision_scripts_post ) {
		const char* (*postHookFunc) (const char* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_scripts_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_scripts_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_sysinfo_vcsrevision_reload(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sysinfo_vcsrevision_reload_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_reload_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_reload_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sysinfo.vcsrevision_reload();
	}
	if( HPMHooks.count.HP_sysinfo_vcsrevision_reload_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_vcsrevision_reload_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_vcsrevision_reload_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
bool HP_sysinfo_is_superuser(void) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_sysinfo_is_superuser_pre ) {
		bool (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is_superuser_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_is_superuser_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.sysinfo.is_superuser();
	}
	if( HPMHooks.count.HP_sysinfo_is_superuser_post ) {
		bool (*postHookFunc) (bool retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_is_superuser_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_is_superuser_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
void HP_sysinfo_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sysinfo_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sysinfo.init();
	}
	if( HPMHooks.count.HP_sysinfo_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_sysinfo_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_sysinfo_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_sysinfo_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.sysinfo.final();
	}
	if( HPMHooks.count.HP_sysinfo_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_sysinfo_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_sysinfo_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* thread_interface */
void HP_thread_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_thread_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.thread.init();
	}
	if( HPMHooks.count.HP_thread_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_thread_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_thread_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.thread.final();
	}
	if( HPMHooks.count.HP_thread_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
struct thread_handle* HP_thread_create(threadFunc entry_point, void *param) {
	int hIndex = 0;
	struct thread_handle* retVal___ = NULL;
	if( HPMHooks.count.HP_thread_create_pre ) {
		struct thread_handle* (*preHookFunc) (threadFunc *entry_point, void **param);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_create_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_create_pre[hIndex].func;
			retVal___ = preHookFunc(&entry_point, &param);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.thread.create(entry_point, param);
	}
	if( HPMHooks.count.HP_thread_create_post ) {
		struct thread_handle* (*postHookFunc) (struct thread_handle* retVal___, threadFunc entry_point, void *param);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_create_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_create_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, entry_point, param);
		}
	}
	return retVal___;
}
struct thread_handle* HP_thread_create_opt(threadFunc entry_point, void *param, size_t stack_size, enum thread_priority prio) {
	int hIndex = 0;
	struct thread_handle* retVal___ = NULL;
	if( HPMHooks.count.HP_thread_create_opt_pre ) {
		struct thread_handle* (*preHookFunc) (threadFunc *entry_point, void **param, size_t *stack_size, enum thread_priority *prio);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_create_opt_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_create_opt_pre[hIndex].func;
			retVal___ = preHookFunc(&entry_point, &param, &stack_size, &prio);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.thread.create_opt(entry_point, param, stack_size, prio);
	}
	if( HPMHooks.count.HP_thread_create_opt_post ) {
		struct thread_handle* (*postHookFunc) (struct thread_handle* retVal___, threadFunc entry_point, void *param, size_t stack_size, enum thread_priority prio);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_create_opt_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_create_opt_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, entry_point, param, stack_size, prio);
		}
	}
	return retVal___;
}
void HP_thread_destroy(struct thread_handle *handle) {
	int hIndex = 0;
	if( HPMHooks.count.HP_thread_destroy_pre ) {
		void (*preHookFunc) (struct thread_handle **handle);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_destroy_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_destroy_pre[hIndex].func;
			preHookFunc(&handle);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.thread.destroy(handle);
	}
	if( HPMHooks.count.HP_thread_destroy_post ) {
		void (*postHookFunc) (struct thread_handle *handle);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_destroy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_destroy_post[hIndex].func;
			postHookFunc(handle);
		}
	}
	return;
}
struct thread_handle* HP_thread_self(void) {
	int hIndex = 0;
	struct thread_handle* retVal___ = NULL;
	if( HPMHooks.count.HP_thread_self_pre ) {
		struct thread_handle* (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_self_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_self_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.thread.self();
	}
	if( HPMHooks.count.HP_thread_self_post ) {
		struct thread_handle* (*postHookFunc) (struct thread_handle* retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_self_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_self_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_thread_get_tid(void) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_thread_get_tid_pre ) {
		int (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_get_tid_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_get_tid_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.thread.get_tid();
	}
	if( HPMHooks.count.HP_thread_get_tid_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_get_tid_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_get_tid_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
bool HP_thread_wait(struct thread_handle *handle, void **out_exit_code) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_thread_wait_pre ) {
		bool (*preHookFunc) (struct thread_handle **handle, void ***out_exit_code);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_wait_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_wait_pre[hIndex].func;
			retVal___ = preHookFunc(&handle, &out_exit_code);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.thread.wait(handle, out_exit_code);
	}
	if( HPMHooks.count.HP_thread_wait_post ) {
		bool (*postHookFunc) (bool retVal___, struct thread_handle *handle, void **out_exit_code);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_wait_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_wait_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, handle, out_exit_code);
		}
	}
	return retVal___;
}
void HP_thread_prio_set(struct thread_handle *handle, enum thread_priority prio) {
	int hIndex = 0;
	if( HPMHooks.count.HP_thread_prio_set_pre ) {
		void (*preHookFunc) (struct thread_handle **handle, enum thread_priority *prio);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_prio_set_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_prio_set_pre[hIndex].func;
			preHookFunc(&handle, &prio);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.thread.prio_set(handle, prio);
	}
	if( HPMHooks.count.HP_thread_prio_set_post ) {
		void (*postHookFunc) (struct thread_handle *handle, enum thread_priority prio);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_prio_set_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_prio_set_post[hIndex].func;
			postHookFunc(handle, prio);
		}
	}
	return;
}
enum thread_priority HP_thread_prio_get(struct thread_handle *handle) {
	int hIndex = 0;
	enum thread_priority retVal___ = THREADPRIO_NORMAL;
	if( HPMHooks.count.HP_thread_prio_get_pre ) {
		enum thread_priority (*preHookFunc) (struct thread_handle **handle);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_prio_get_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_prio_get_pre[hIndex].func;
			retVal___ = preHookFunc(&handle);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.thread.prio_get(handle);
	}
	if( HPMHooks.count.HP_thread_prio_get_post ) {
		enum thread_priority (*postHookFunc) (enum thread_priority retVal___, struct thread_handle *handle);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_prio_get_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_prio_get_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, handle);
		}
	}
	return retVal___;
}
void HP_thread_yield(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_thread_yield_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_yield_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_thread_yield_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.thread.yield();
	}
	if( HPMHooks.count.HP_thread_yield_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_thread_yield_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_thread_yield_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* timer_interface */
int64 HP_timer_gettick(void) {
	int hIndex = 0;
	int64 retVal___ = 0;
	if( HPMHooks.count.HP_timer_gettick_pre ) {
		int64 (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_gettick_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.gettick();
	}
	if( HPMHooks.count.HP_timer_gettick_post ) {
		int64 (*postHookFunc) (int64 retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_gettick_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int64 HP_timer_gettick_nocache(void) {
	int hIndex = 0;
	int64 retVal___ = 0;
	if( HPMHooks.count.HP_timer_gettick_nocache_pre ) {
		int64 (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_nocache_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_gettick_nocache_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.gettick_nocache();
	}
	if( HPMHooks.count.HP_timer_gettick_nocache_post ) {
		int64 (*postHookFunc) (int64 retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_gettick_nocache_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_gettick_nocache_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_timer_add(int64 tick, TimerFunc func, int id, intptr_t data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_timer_add_pre ) {
		int (*preHookFunc) (int64 *tick, TimerFunc *func, int *id, intptr_t *data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_add_pre[hIndex].func;
			retVal___ = preHookFunc(&tick, &func, &id, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.add(tick, func, id, data);
	}
	if( HPMHooks.count.HP_timer_add_post ) {
		int (*postHookFunc) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_add_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tick, func, id, data);
		}
	}
	return retVal___;
}
int HP_timer_add_interval(int64 tick, TimerFunc func, int id, intptr_t data, int interval) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_timer_add_interval_pre ) {
		int (*preHookFunc) (int64 *tick, TimerFunc *func, int *id, intptr_t *data, int *interval);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_add_interval_pre[hIndex].func;
			retVal___ = preHookFunc(&tick, &func, &id, &data, &interval);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.add_interval(tick, func, id, data, interval);
	}
	if( HPMHooks.count.HP_timer_add_interval_post ) {
		int (*postHookFunc) (int retVal___, int64 tick, TimerFunc func, int id, intptr_t data, int interval);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_interval_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_add_interval_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tick, func, id, data, interval);
		}
	}
	return retVal___;
}
const struct TimerData* HP_timer_get(int tid) {
	int hIndex = 0;
	const struct TimerData* retVal___ = NULL;
	if( HPMHooks.count.HP_timer_get_pre ) {
		const struct TimerData* (*preHookFunc) (int *tid);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_get_pre[hIndex].func;
			retVal___ = preHookFunc(&tid);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.get(tid);
	}
	if( HPMHooks.count.HP_timer_get_post ) {
		const struct TimerData* (*postHookFunc) (const struct TimerData* retVal___, int tid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_get_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid);
		}
	}
	return retVal___;
}
int HP_timer_delete(int tid, TimerFunc func) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_timer_delete_pre ) {
		int (*preHookFunc) (int *tid, TimerFunc *func);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_delete_pre[hIndex].func;
			retVal___ = preHookFunc(&tid, &func);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.delete(tid, func);
	}
	if( HPMHooks.count.HP_timer_delete_post ) {
		int (*postHookFunc) (int retVal___, int tid, TimerFunc func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_delete_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_delete_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, func);
		}
	}
	return retVal___;
}
int64 HP_timer_addtick(int tid, int64 tick) {
	int hIndex = 0;
	int64 retVal___ = 0;
	if( HPMHooks.count.HP_timer_addtick_pre ) {
		int64 (*preHookFunc) (int *tid, int64 *tick);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_addtick_pre[hIndex].func;
			retVal___ = preHookFunc(&tid, &tick);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.addtick(tid, tick);
	}
	if( HPMHooks.count.HP_timer_addtick_post ) {
		int64 (*postHookFunc) (int64 retVal___, int tid, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_addtick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_addtick_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick);
		}
	}
	return retVal___;
}
int64 HP_timer_settick(int tid, int64 tick) {
	int hIndex = 0;
	int64 retVal___ = 0;
	if( HPMHooks.count.HP_timer_settick_pre ) {
		int64 (*preHookFunc) (int *tid, int64 *tick);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_settick_pre[hIndex].func;
			retVal___ = preHookFunc(&tid, &tick);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.settick(tid, tick);
	}
	if( HPMHooks.count.HP_timer_settick_post ) {
		int64 (*postHookFunc) (int64 retVal___, int tid, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_settick_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_settick_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick);
		}
	}
	return retVal___;
}
int HP_timer_add_func_list(TimerFunc func, char *name) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_timer_add_func_list_pre ) {
		int (*preHookFunc) (TimerFunc *func, char **name);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_add_func_list_pre[hIndex].func;
			retVal___ = preHookFunc(&func, &name);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.add_func_list(func, name);
	}
	if( HPMHooks.count.HP_timer_add_func_list_post ) {
		int (*postHookFunc) (int retVal___, TimerFunc func, char *name);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_add_func_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_add_func_list_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, func, name);
		}
	}
	return retVal___;
}
unsigned long HP_timer_get_uptime(void) {
	int hIndex = 0;
	unsigned long retVal___ = 0;
	if( HPMHooks.count.HP_timer_get_uptime_pre ) {
		unsigned long (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_uptime_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_get_uptime_pre[hIndex].func;
			retVal___ = preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.get_uptime();
	}
	if( HPMHooks.count.HP_timer_get_uptime_post ) {
		unsigned long (*postHookFunc) (unsigned long retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_get_uptime_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_get_uptime_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
int HP_timer_perform(int64 tick) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_timer_perform_pre ) {
		int (*preHookFunc) (int64 *tick);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_perform_pre[hIndex].func;
			retVal___ = preHookFunc(&tick);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.timer.perform(tick);
	}
	if( HPMHooks.count.HP_timer_perform_post ) {
		int (*postHookFunc) (int retVal___, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_perform_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_perform_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tick);
		}
	}
	return retVal___;
}
void HP_timer_init(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_timer_init_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_init_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_init_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.timer.init();
	}
	if( HPMHooks.count.HP_timer_init_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_init_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_timer_final(void) {
	int hIndex = 0;
	if( HPMHooks.count.HP_timer_final_pre ) {
		void (*preHookFunc) (void);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_final_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_timer_final_pre[hIndex].func;
			preHookFunc();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.timer.final();
	}
	if( HPMHooks.count.HP_timer_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_timer_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_timer_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
/* trade_interface */
void HP_trade_request(struct map_session_data *sd, struct map_session_data *target_sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_trade_request_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, struct map_session_data **target_sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.trade.request(sd, target_sd);
	}
	if( HPMHooks.count.HP_trade_request_post ) {
		void (*postHookFunc) (struct map_session_data *sd, struct map_session_data *target_sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_request_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_request_post[hIndex].func;
			postHookFunc(sd, target_sd);
		}
	}
	return;
}
void HP_trade_ack(struct map_session_data *sd, int type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_trade_ack_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *type);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.trade.ack(sd, type);
	}
	if( HPMHooks.count.HP_trade_ack_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_ack_post[hIndex].func;
			postHookFunc(sd, type);
		}
	}
	return;
}
int HP_trade_check_impossible(struct map_session_data *sd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.trade.check_impossible(sd);
	}
	if( HPMHooks.count.HP_trade_check_impossible_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_impossible_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_check_impossible_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd);
		}
	}
	return retVal___;
}
int HP_trade_check(struct map_session_data *sd, struct map_session_data *tsd) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.trade.check(sd, tsd);
	}
	if( HPMHooks.count.HP_trade_check_post ) {
		int (*postHookFunc) (int retVal___, struct map_session_data *sd, struct map_session_data *tsd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_check_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_check_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, tsd);
		}
	}
	return retVal___;
}
void HP_trade_additem(struct map_session_data *sd, short index, short amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_trade_additem_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, short *index, short *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.trade.additem(sd, index, amount);
	}
	if( HPMHooks.count.HP_trade_additem_post ) {
		void (*postHookFunc) (struct map_session_data *sd, short index, short amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_additem_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_additem_post[hIndex].func;
			postHookFunc(sd, index, amount);
		}
	}
	return;
}
void HP_trade_addzeny(struct map_session_data *sd, int amount) {
	int hIndex = 0;
	if( HPMHooks.count.HP_trade_addzeny_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *amount);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.trade.addzeny(sd, amount);
	}
	if( HPMHooks.count.HP_trade_addzeny_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int amount);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_addzeny_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_addzeny_post[hIndex].func;
			postHookFunc(sd, amount);
		}
	}
	return;
}
void HP_trade_ok(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_trade_ok_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.trade.ok(sd);
	}
	if( HPMHooks.count.HP_trade_ok_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_ok_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_ok_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_trade_cancel(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_trade_cancel_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.trade.cancel(sd);
	}
	if( HPMHooks.count.HP_trade_cancel_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_cancel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_cancel_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_trade_commit(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_trade_commit_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.trade.commit(sd);
	}
	if( HPMHooks.count.HP_trade_commit_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_trade_commit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_trade_commit_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
/* unit_interface */
int HP_unit_init(bool minimal) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.init(minimal);
	}
	if( HPMHooks.count.HP_unit_init_post ) {
		int (*postHookFunc) (int retVal___, bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_init_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, minimal);
		}
	}
	return retVal___;
}
int HP_unit_final(void) {
	int hIndex = 0;
	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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.final();
	}
	if( HPMHooks.count.HP_unit_final_post ) {
		int (*postHookFunc) (int retVal___);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_final_post[hIndex].func;
			retVal___ = postHookFunc(retVal___);
		}
	}
	return retVal___;
}
struct unit_data* HP_unit_bl2ud(struct block_list *bl) {
	int hIndex = 0;
	struct unit_data* retVal___ = NULL;
	if( HPMHooks.count.HP_unit_bl2ud_pre ) {
		struct unit_data* (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.bl2ud(bl);
	}
	if( HPMHooks.count.HP_unit_bl2ud_post ) {
		struct unit_data* (*postHookFunc) (struct unit_data* retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_bl2ud_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
struct unit_data* HP_unit_bl2ud2(struct block_list *bl) {
	int hIndex = 0;
	struct unit_data* retVal___ = NULL;
	if( HPMHooks.count.HP_unit_bl2ud2_pre ) {
		struct unit_data* (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.bl2ud2(bl);
	}
	if( HPMHooks.count.HP_unit_bl2ud2_post ) {
		struct unit_data* (*postHookFunc) (struct unit_data* retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_bl2ud2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_bl2ud2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
void HP_unit_init_ud(struct unit_data *ud) {
	int hIndex = 0;
	if( HPMHooks.count.HP_unit_init_ud_pre ) {
		void (*preHookFunc) (struct unit_data **ud);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_ud_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_unit_init_ud_pre[hIndex].func;
			preHookFunc(&ud);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.unit.init_ud(ud);
	}
	if( HPMHooks.count.HP_unit_init_ud_post ) {
		void (*postHookFunc) (struct unit_data *ud);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_init_ud_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_init_ud_post[hIndex].func;
			postHookFunc(ud);
		}
	}
	return;
}
int HP_unit_attack_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.attack_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_unit_attack_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_attack_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_unit_walktoxy_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.walktoxy_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_unit_walktoxy_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_walktoxy_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_unit_walktoxy_sub(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.walktoxy_sub(bl);
	}
	if( HPMHooks.count.HP_unit_walktoxy_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_walktoxy_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_unit_delay_walktoxy_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.delay_walktoxy_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_unit_delay_walktoxy_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_delay_walktoxy_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_delay_walktoxy_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_unit_walktoxy(struct block_list *bl, short x, short y, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.walktoxy(bl, x, y, flag);
	}
	if( HPMHooks.count.HP_unit_walktoxy_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, short x, short y, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktoxy_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_walktoxy_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, x, y, flag);
		}
	}
	return retVal___;
}
int HP_unit_walktobl_sub(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.walktobl_sub(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_unit_walktobl_sub_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_walktobl_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_unit_walktobl(struct block_list *bl, struct block_list *tbl, int range, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.walktobl(bl, tbl, range, flag);
	}
	if( HPMHooks.count.HP_unit_walktobl_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, struct block_list *tbl, int range, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_walktobl_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_walktobl_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, tbl, range, flag);
		}
	}
	return retVal___;
}
bool HP_unit_run(struct block_list *bl, struct map_session_data *sd, enum sc_type type) {
	int hIndex = 0;
	bool retVal___ = false;
	if( HPMHooks.count.HP_unit_run_pre ) {
		bool (*preHookFunc) (struct block_list **bl, struct map_session_data **sd, enum sc_type *type);
		*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, &sd, &type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.run(bl, sd, type);
	}
	if( HPMHooks.count.HP_unit_run_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct map_session_data *sd, enum sc_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_run_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, sd, type);
		}
	}
	return retVal___;
}
void HP_unit_run_hit(struct block_list *bl, struct status_change *sc, struct map_session_data *sd, enum sc_type type) {
	int hIndex = 0;
	if( HPMHooks.count.HP_unit_run_hit_pre ) {
		void (*preHookFunc) (struct block_list **bl, struct status_change **sc, struct map_session_data **sd, enum sc_type *type);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_hit_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_unit_run_hit_pre[hIndex].func;
			preHookFunc(&bl, &sc, &sd, &type);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.unit.run_hit(bl, sc, sd, type);
	}
	if( HPMHooks.count.HP_unit_run_hit_post ) {
		void (*postHookFunc) (struct block_list *bl, struct status_change *sc, struct map_session_data *sd, enum sc_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_run_hit_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_run_hit_post[hIndex].func;
			postHookFunc(bl, sc, sd, type);
		}
	}
	return;
}
int HP_unit_escape(struct block_list *bl, struct block_list *target, short dist) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.escape(bl, target, dist);
	}
	if( HPMHooks.count.HP_unit_escape_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, struct block_list *target, short dist);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_escape_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_escape_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, target, dist);
		}
	}
	return retVal___;
}
int HP_unit_movepos(struct block_list *bl, short dst_x, short dst_y, int easy, bool checkpath) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.movepos(bl, dst_x, dst_y, easy, checkpath);
	}
	if( HPMHooks.count.HP_unit_movepos_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, short dst_x, short dst_y, int easy, bool checkpath);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_movepos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_movepos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, dst_x, dst_y, easy, checkpath);
		}
	}
	return retVal___;
}
int HP_unit_setdir(struct block_list *bl, unsigned char dir) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.setdir(bl, dir);
	}
	if( HPMHooks.count.HP_unit_setdir_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, unsigned char dir);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_setdir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_setdir_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, dir);
		}
	}
	return retVal___;
}
uint8 HP_unit_getdir(struct block_list *bl) {
	int hIndex = 0;
	uint8 retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.getdir(bl);
	}
	if( HPMHooks.count.HP_unit_getdir_post ) {
		uint8 (*postHookFunc) (uint8 retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_getdir_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_getdir_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_unit_blown(struct block_list *bl, int dx, int dy, int count, int flag) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.blown(bl, dx, dy, count, flag);
	}
	if( HPMHooks.count.HP_unit_blown_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int dx, int dy, int count, int flag);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_blown_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_blown_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, dx, dy, count, flag);
		}
	}
	return retVal___;
}
int HP_unit_warp(struct block_list *bl, short m, short x, short y, clr_type type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.warp(bl, m, x, y, type);
	}
	if( HPMHooks.count.HP_unit_warp_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, short m, short x, short y, clr_type type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_warp_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_warp_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, m, x, y, type);
		}
	}
	return retVal___;
}
int HP_unit_stop_walking(struct block_list *bl, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.stop_walking(bl, type);
	}
	if( HPMHooks.count.HP_unit_stop_walking_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_walking_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_stop_walking_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, type);
		}
	}
	return retVal___;
}
int HP_unit_skilluse_id(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.skilluse_id(src, target_id, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_unit_skilluse_id_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_skilluse_id_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target_id, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_unit_step_timer(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	int retVal___ = 0;
	if( HPMHooks.count.HP_unit_step_timer_pre ) {
		int (*preHookFunc) (int *tid, int64 *tick, int *id, intptr_t *data);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_step_timer_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_unit_step_timer_pre[hIndex].func;
			retVal___ = preHookFunc(&tid, &tick, &id, &data);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.step_timer(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_unit_step_timer_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_step_timer_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_step_timer_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
void HP_unit_stop_stepaction(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_unit_stop_stepaction_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*HPMforce_return = false;
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_stepaction_pre; hIndex++ ) {
			preHookFunc = HPMHooks.list.HP_unit_stop_stepaction_pre[hIndex].func;
			preHookFunc(&bl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.unit.stop_stepaction(bl);
	}
	if( HPMHooks.count.HP_unit_stop_stepaction_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_stepaction_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_stop_stepaction_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
int HP_unit_is_walking(struct block_list *bl) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.is_walking(bl);
	}
	if( HPMHooks.count.HP_unit_is_walking_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_is_walking_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_is_walking_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_unit_can_move(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.can_move(bl);
	}
	if( HPMHooks.count.HP_unit_can_move_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_move_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_can_move_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_unit_resume_running(int tid, int64 tick, int id, intptr_t data) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.resume_running(tid, tick, id, data);
	}
	if( HPMHooks.count.HP_unit_resume_running_post ) {
		int (*postHookFunc) (int retVal___, int tid, int64 tick, int id, intptr_t data);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_resume_running_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_resume_running_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, tid, tick, id, data);
		}
	}
	return retVal___;
}
int HP_unit_set_walkdelay(struct block_list *bl, int64 tick, int delay, int type) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.set_walkdelay(bl, tick, delay, type);
	}
	if( HPMHooks.count.HP_unit_set_walkdelay_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int64 tick, int delay, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_walkdelay_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_set_walkdelay_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, tick, delay, type);
		}
	}
	return retVal___;
}
int HP_unit_skilluse_id2(struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.skilluse_id2(src, target_id, skill_id, skill_lv, casttime, castcancel);
	}
	if( HPMHooks.count.HP_unit_skilluse_id2_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, int target_id, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_id2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_skilluse_id2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target_id, skill_id, skill_lv, casttime, castcancel);
		}
	}
	return retVal___;
}
int HP_unit_skilluse_pos(struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.skilluse_pos(src, skill_x, skill_y, skill_id, skill_lv);
	}
	if( HPMHooks.count.HP_unit_skilluse_pos_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_skilluse_pos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, skill_x, skill_y, skill_id, skill_lv);
		}
	}
	return retVal___;
}
int HP_unit_skilluse_pos2(struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.skilluse_pos2(src, skill_x, skill_y, skill_id, skill_lv, casttime, castcancel);
	}
	if( HPMHooks.count.HP_unit_skilluse_pos2_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, short skill_x, short skill_y, uint16 skill_id, uint16 skill_lv, int casttime, int castcancel);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skilluse_pos2_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_skilluse_pos2_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, skill_x, skill_y, skill_id, skill_lv, casttime, castcancel);
		}
	}
	return retVal___;
}
int HP_unit_set_target(struct unit_data *ud, int target_id) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.set_target(ud, target_id);
	}
	if( HPMHooks.count.HP_unit_set_target_post ) {
		int (*postHookFunc) (int retVal___, struct unit_data *ud, int target_id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_set_target_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_set_target_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, ud, target_id);
		}
	}
	return retVal___;
}
void HP_unit_stop_attack(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_unit_stop_attack_pre ) {
		void (*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;
			preHookFunc(&bl);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.unit.stop_attack(bl);
	}
	if( HPMHooks.count.HP_unit_stop_attack_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_stop_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_stop_attack_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
int HP_unit_unattackable(struct block_list *bl) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.unattackable(bl);
	}
	if( HPMHooks.count.HP_unit_unattackable_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_unattackable_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_unattackable_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_unit_attack(struct block_list *src, int target_id, int continuous) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.attack(src, target_id, continuous);
	}
	if( HPMHooks.count.HP_unit_attack_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, int target_id, int continuous);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_attack_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target_id, continuous);
		}
	}
	return retVal___;
}
int HP_unit_cancel_combo(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.cancel_combo(bl);
	}
	if( HPMHooks.count.HP_unit_cancel_combo_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_cancel_combo_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_cancel_combo_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
bool HP_unit_can_reach_pos(struct block_list *bl, int x, int y, int easy) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.can_reach_pos(bl, x, y, easy);
	}
	if( HPMHooks.count.HP_unit_can_reach_pos_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl, int x, int y, int easy);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_pos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_can_reach_pos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, x, y, easy);
		}
	}
	return retVal___;
}
bool HP_unit_can_reach_bl(struct block_list *bl, struct block_list *tbl, int range, int easy, short *x, short *y) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.can_reach_bl(bl, tbl, range, easy, x, y);
	}
	if( HPMHooks.count.HP_unit_can_reach_bl_post ) {
		bool (*postHookFunc) (bool retVal___, struct block_list *bl, struct block_list *tbl, int range, int easy, short *x, short *y);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_can_reach_bl_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_can_reach_bl_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, tbl, range, easy, x, y);
		}
	}
	return retVal___;
}
int HP_unit_calc_pos(struct block_list *bl, int tx, int ty, uint8 dir) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.calc_pos(bl, tx, ty, dir);
	}
	if( HPMHooks.count.HP_unit_calc_pos_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int tx, int ty, uint8 dir);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_calc_pos_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_calc_pos_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, tx, ty, dir);
		}
	}
	return retVal___;
}
int HP_unit_attack_timer_sub(struct block_list *src, int tid, int64 tick) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.attack_timer_sub(src, tid, tick);
	}
	if( HPMHooks.count.HP_unit_attack_timer_sub_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, int tid, int64 tick);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_attack_timer_sub_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_attack_timer_sub_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, tid, tick);
		}
	}
	return retVal___;
}
int HP_unit_skillcastcancel(struct block_list *bl, int type) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.skillcastcancel(bl, type);
	}
	if( HPMHooks.count.HP_unit_skillcastcancel_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, int type);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_skillcastcancel_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_skillcastcancel_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, type);
		}
	}
	return retVal___;
}
void HP_unit_dataset(struct block_list *bl) {
	int hIndex = 0;
	if( HPMHooks.count.HP_unit_dataset_pre ) {
		void (*preHookFunc) (struct block_list **bl);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.unit.dataset(bl);
	}
	if( HPMHooks.count.HP_unit_dataset_post ) {
		void (*postHookFunc) (struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_dataset_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_dataset_post[hIndex].func;
			postHookFunc(bl);
		}
	}
	return;
}
int HP_unit_counttargeted(struct block_list *bl) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.counttargeted(bl);
	}
	if( HPMHooks.count.HP_unit_counttargeted_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_counttargeted_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_counttargeted_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl);
		}
	}
	return retVal___;
}
int HP_unit_fixdamage(struct block_list *src, struct block_list *target, int sdelay, int ddelay, int64 damage, short div, unsigned char type, int64 damage2) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.fixdamage(src, target, sdelay, ddelay, damage, div, type, damage2);
	}
	if( HPMHooks.count.HP_unit_fixdamage_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *src, struct block_list *target, int sdelay, int ddelay, int64 damage, short div, unsigned char type, int64 damage2);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_fixdamage_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_fixdamage_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, src, target, sdelay, ddelay, damage, div, type, damage2);
		}
	}
	return retVal___;
}
int HP_unit_changeviewsize(struct block_list *bl, short size) {
	int hIndex = 0;
	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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.changeviewsize(bl, size);
	}
	if( HPMHooks.count.HP_unit_changeviewsize_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, short size);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_changeviewsize_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_changeviewsize_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, size);
		}
	}
	return retVal___;
}
int HP_unit_remove_map(struct block_list *bl, clr_type clrtype, const char *file, int line, const char *func) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.remove_map(bl, clrtype, file, line, func);
	}
	if( HPMHooks.count.HP_unit_remove_map_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, clr_type clrtype, const char *file, int line, const char *func);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_remove_map_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, clrtype, file, line, func);
		}
	}
	return retVal___;
}
void HP_unit_remove_map_pc(struct map_session_data *sd, clr_type clrtype) {
	int hIndex = 0;
	if( HPMHooks.count.HP_unit_remove_map_pc_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, clr_type *clrtype);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.unit.remove_map_pc(sd, clrtype);
	}
	if( HPMHooks.count.HP_unit_remove_map_pc_post ) {
		void (*postHookFunc) (struct map_session_data *sd, clr_type clrtype);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_remove_map_pc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_remove_map_pc_post[hIndex].func;
			postHookFunc(sd, clrtype);
		}
	}
	return;
}
void HP_unit_free_pc(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_unit_free_pc_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.unit.free_pc(sd);
	}
	if( HPMHooks.count.HP_unit_free_pc_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_pc_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_free_pc_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
int HP_unit_free(struct block_list *bl, clr_type clrtype) {
	int hIndex = 0;
	int retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.unit.free(bl, clrtype);
	}
	if( HPMHooks.count.HP_unit_free_post ) {
		int (*postHookFunc) (int retVal___, struct block_list *bl, clr_type clrtype);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_unit_free_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_unit_free_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, bl, clrtype);
		}
	}
	return retVal___;
}
/* vending_interface */
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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.vending.init(minimal);
	}
	if( HPMHooks.count.HP_vending_init_post ) {
		void (*postHookFunc) (bool minimal);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_init_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_vending_init_post[hIndex].func;
			postHookFunc(minimal);
		}
	}
	return;
}
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();
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.vending.final();
	}
	if( HPMHooks.count.HP_vending_final_post ) {
		void (*postHookFunc) (void);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_final_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_vending_final_post[hIndex].func;
			postHookFunc();
		}
	}
	return;
}
void HP_vending_close(struct map_session_data *sd) {
	int hIndex = 0;
	if( HPMHooks.count.HP_vending_close_pre ) {
		void (*preHookFunc) (struct map_session_data **sd);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.vending.close(sd);
	}
	if( HPMHooks.count.HP_vending_close_post ) {
		void (*postHookFunc) (struct map_session_data *sd);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_close_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_vending_close_post[hIndex].func;
			postHookFunc(sd);
		}
	}
	return;
}
void HP_vending_open(struct map_session_data *sd, const char *message, const uint8 *data, int count) {
	int hIndex = 0;
	if( HPMHooks.count.HP_vending_open_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, const char **message, const uint8 **data, int *count);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.vending.open(sd, message, data, count);
	}
	if( HPMHooks.count.HP_vending_open_post ) {
		void (*postHookFunc) (struct map_session_data *sd, const char *message, const uint8 *data, int count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_open_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_vending_open_post[hIndex].func;
			postHookFunc(sd, message, data, count);
		}
	}
	return;
}
void HP_vending_list(struct map_session_data *sd, unsigned int id) {
	int hIndex = 0;
	if( HPMHooks.count.HP_vending_list_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, unsigned int *id);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.vending.list(sd, id);
	}
	if( HPMHooks.count.HP_vending_list_post ) {
		void (*postHookFunc) (struct map_session_data *sd, unsigned int id);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_list_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_vending_list_post[hIndex].func;
			postHookFunc(sd, id);
		}
	}
	return;
}
void HP_vending_purchase(struct map_session_data *sd, int aid, unsigned int uid, const uint8 *data, int count) {
	int hIndex = 0;
	if( HPMHooks.count.HP_vending_purchase_pre ) {
		void (*preHookFunc) (struct map_session_data **sd, int *aid, unsigned int *uid, const uint8 **data, int *count);
		*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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return;
		}
	}
	{
		HPMHooks.source.vending.purchase(sd, aid, uid, data, count);
	}
	if( HPMHooks.count.HP_vending_purchase_post ) {
		void (*postHookFunc) (struct map_session_data *sd, int aid, unsigned int uid, const uint8 *data, int count);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_purchase_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_vending_purchase_post[hIndex].func;
			postHookFunc(sd, aid, uid, data, count);
		}
	}
	return;
}
bool HP_vending_search(struct map_session_data *sd, unsigned short nameid) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.vending.search(sd, nameid);
	}
	if( HPMHooks.count.HP_vending_search_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, unsigned short nameid);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_search_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_vending_search_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, nameid);
		}
	}
	return retVal___;
}
bool HP_vending_searchall(struct map_session_data *sd, const struct s_search_store_search *s) {
	int hIndex = 0;
	bool retVal___ = 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);
		}
		if( *HPMforce_return ) {
			*HPMforce_return = false;
			return retVal___;
		}
	}
	{
		retVal___ = HPMHooks.source.vending.searchall(sd, s);
	}
	if( HPMHooks.count.HP_vending_searchall_post ) {
		bool (*postHookFunc) (bool retVal___, struct map_session_data *sd, const struct s_search_store_search *s);
		for(hIndex = 0; hIndex < HPMHooks.count.HP_vending_searchall_post; hIndex++ ) {
			postHookFunc = HPMHooks.list.HP_vending_searchall_post[hIndex].func;
			retVal___ = postHookFunc(retVal___, sd, s);
		}
	}
	return retVal___;
}