HPM Hooks Update

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

3 files changed, 1133 insertions, 1 deletions

diff --git a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
index c2c6daf58..9090af876 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.HPMHooksCore.inc
@@ -165,6 +165,14 @@ struct {
 	struct HPMHookPoint *HP_battle_get_enemy_area_post;
 	struct HPMHookPoint *HP_battle_damage_area_pre;
 	struct HPMHookPoint *HP_battle_damage_area_post;
+	struct HPMHookPoint *HP_battle_calc_masteryfix_unknown_pre;
+	struct HPMHookPoint *HP_battle_calc_masteryfix_unknown_post;
+	struct HPMHookPoint *HP_battle_calc_skillratio_magic_unknown_pre;
+	struct HPMHookPoint *HP_battle_calc_skillratio_magic_unknown_post;
+	struct HPMHookPoint *HP_battle_calc_skillratio_weapon_unknown_pre;
+	struct HPMHookPoint *HP_battle_calc_skillratio_weapon_unknown_post;
+	struct HPMHookPoint *HP_battle_calc_misc_attack_unknown_pre;
+	struct HPMHookPoint *HP_battle_calc_misc_attack_unknown_post;
 	struct HPMHookPoint *HP_bg_init_pre;
 	struct HPMHookPoint *HP_bg_init_post;
 	struct HPMHookPoint *HP_bg_final_pre;
@@ -4711,6 +4719,70 @@ struct {
 	struct HPMHookPoint *HP_skill_get_new_group_id_post;
 	struct HPMHookPoint *HP_skill_check_shadowform_pre;
 	struct HPMHookPoint *HP_skill_check_shadowform_post;
+	struct HPMHookPoint *HP_skill_castend_damage_id_unknown_pre;
+	struct HPMHookPoint *HP_skill_castend_damage_id_unknown_post;
+	struct HPMHookPoint *HP_skill_additional_effect_unknown_pre;
+	struct HPMHookPoint *HP_skill_additional_effect_unknown_post;
+	struct HPMHookPoint *HP_skill_counter_additional_effect_unknown_pre;
+	struct HPMHookPoint *HP_skill_counter_additional_effect_unknown_post;
+	struct HPMHookPoint *HP_skill_attack_combo1_unknown_pre;
+	struct HPMHookPoint *HP_skill_attack_combo1_unknown_post;
+	struct HPMHookPoint *HP_skill_attack_combo2_unknown_pre;
+	struct HPMHookPoint *HP_skill_attack_combo2_unknown_post;
+	struct HPMHookPoint *HP_skill_attack_display_unknown_pre;
+	struct HPMHookPoint *HP_skill_attack_display_unknown_post;
+	struct HPMHookPoint *HP_skill_attack_copy_unknown_pre;
+	struct HPMHookPoint *HP_skill_attack_copy_unknown_post;
+	struct HPMHookPoint *HP_skill_attack_dir_unknown_pre;
+	struct HPMHookPoint *HP_skill_attack_dir_unknown_post;
+	struct HPMHookPoint *HP_skill_attack_blow_unknown_pre;
+	struct HPMHookPoint *HP_skill_attack_blow_unknown_post;
+	struct HPMHookPoint *HP_skill_attack_post_unknown_pre;
+	struct HPMHookPoint *HP_skill_attack_post_unknown_post;
+	struct HPMHookPoint *HP_skill_timerskill_dead_unknown_pre;
+	struct HPMHookPoint *HP_skill_timerskill_dead_unknown_post;
+	struct HPMHookPoint *HP_skill_timerskill_target_unknown_pre;
+	struct HPMHookPoint *HP_skill_timerskill_target_unknown_post;
+	struct HPMHookPoint *HP_skill_timerskill_notarget_unknown_pre;
+	struct HPMHookPoint *HP_skill_timerskill_notarget_unknown_post;
+	struct HPMHookPoint *HP_skill_cleartimerskill_unknown_pre;
+	struct HPMHookPoint *HP_skill_cleartimerskill_unknown_post;
+	struct HPMHookPoint *HP_skill_castend_id_unknown_pre;
+	struct HPMHookPoint *HP_skill_castend_id_unknown_post;
+	struct HPMHookPoint *HP_skill_castend_nodamage_id_dead_unknown_pre;
+	struct HPMHookPoint *HP_skill_castend_nodamage_id_dead_unknown_post;
+	struct HPMHookPoint *HP_skill_castend_nodamage_id_undead_unknown_pre;
+	struct HPMHookPoint *HP_skill_castend_nodamage_id_undead_unknown_post;
+	struct HPMHookPoint *HP_skill_castend_nodamage_id_mado_unknown_pre;
+	struct HPMHookPoint *HP_skill_castend_nodamage_id_mado_unknown_post;
+	struct HPMHookPoint *HP_skill_castend_nodamage_id_unknown_pre;
+	struct HPMHookPoint *HP_skill_castend_nodamage_id_unknown_post;
+	struct HPMHookPoint *HP_skill_castend_pos2_effect_unknown_pre;
+	struct HPMHookPoint *HP_skill_castend_pos2_effect_unknown_post;
+	struct HPMHookPoint *HP_skill_castend_pos2_unknown_pre;
+	struct HPMHookPoint *HP_skill_castend_pos2_unknown_post;
+	struct HPMHookPoint *HP_skill_unitsetting1_unknown_pre;
+	struct HPMHookPoint *HP_skill_unitsetting1_unknown_post;
+	struct HPMHookPoint *HP_skill_unitsetting2_unknown_pre;
+	struct HPMHookPoint *HP_skill_unitsetting2_unknown_post;
+	struct HPMHookPoint *HP_skill_unit_onplace_unknown_pre;
+	struct HPMHookPoint *HP_skill_unit_onplace_unknown_post;
+	struct HPMHookPoint *HP_skill_check_condition_castbegin_off_unknown_pre;
+	struct HPMHookPoint *HP_skill_check_condition_castbegin_off_unknown_post;
+	struct HPMHookPoint *HP_skill_check_condition_castbegin_mount_unknown_pre;
+	struct HPMHookPoint *HP_skill_check_condition_castbegin_mount_unknown_post;
+	struct HPMHookPoint *HP_skill_check_condition_castbegin_madogear_unknown_pre;
+	struct HPMHookPoint *HP_skill_check_condition_castbegin_madogear_unknown_post;
+	struct HPMHookPoint *HP_skill_check_condition_castbegin_unknown_pre;
+	struct HPMHookPoint *HP_skill_check_condition_castbegin_unknown_post;
+	struct HPMHookPoint *HP_skill_check_condition_castend_unknown_pre;
+	struct HPMHookPoint *HP_skill_check_condition_castend_unknown_post;
+	struct HPMHookPoint *HP_skill_get_requirement_off_unknown_pre;
+	struct HPMHookPoint *HP_skill_get_requirement_off_unknown_post;
+	struct HPMHookPoint *HP_skill_get_requirement_item_unknown_pre;
+	struct HPMHookPoint *HP_skill_get_requirement_item_unknown_post;
+	struct HPMHookPoint *HP_skill_get_requirement_unknown_pre;
+	struct HPMHookPoint *HP_skill_get_requirement_unknown_post;
 	struct HPMHookPoint *HP_status_init_pre;
 	struct HPMHookPoint *HP_status_init_post;
 	struct HPMHookPoint *HP_status_final_pre;
@@ -5250,6 +5322,14 @@ struct {
 	int HP_battle_get_enemy_area_post;
 	int HP_battle_damage_area_pre;
 	int HP_battle_damage_area_post;
+	int HP_battle_calc_masteryfix_unknown_pre;
+	int HP_battle_calc_masteryfix_unknown_post;
+	int HP_battle_calc_skillratio_magic_unknown_pre;
+	int HP_battle_calc_skillratio_magic_unknown_post;
+	int HP_battle_calc_skillratio_weapon_unknown_pre;
+	int HP_battle_calc_skillratio_weapon_unknown_post;
+	int HP_battle_calc_misc_attack_unknown_pre;
+	int HP_battle_calc_misc_attack_unknown_post;
 	int HP_bg_init_pre;
 	int HP_bg_init_post;
 	int HP_bg_final_pre;
@@ -9796,6 +9876,70 @@ struct {
 	int HP_skill_get_new_group_id_post;
 	int HP_skill_check_shadowform_pre;
 	int HP_skill_check_shadowform_post;
+	int HP_skill_castend_damage_id_unknown_pre;
+	int HP_skill_castend_damage_id_unknown_post;
+	int HP_skill_additional_effect_unknown_pre;
+	int HP_skill_additional_effect_unknown_post;
+	int HP_skill_counter_additional_effect_unknown_pre;
+	int HP_skill_counter_additional_effect_unknown_post;
+	int HP_skill_attack_combo1_unknown_pre;
+	int HP_skill_attack_combo1_unknown_post;
+	int HP_skill_attack_combo2_unknown_pre;
+	int HP_skill_attack_combo2_unknown_post;
+	int HP_skill_attack_display_unknown_pre;
+	int HP_skill_attack_display_unknown_post;
+	int HP_skill_attack_copy_unknown_pre;
+	int HP_skill_attack_copy_unknown_post;
+	int HP_skill_attack_dir_unknown_pre;
+	int HP_skill_attack_dir_unknown_post;
+	int HP_skill_attack_blow_unknown_pre;
+	int HP_skill_attack_blow_unknown_post;
+	int HP_skill_attack_post_unknown_pre;
+	int HP_skill_attack_post_unknown_post;
+	int HP_skill_timerskill_dead_unknown_pre;
+	int HP_skill_timerskill_dead_unknown_post;
+	int HP_skill_timerskill_target_unknown_pre;
+	int HP_skill_timerskill_target_unknown_post;
+	int HP_skill_timerskill_notarget_unknown_pre;
+	int HP_skill_timerskill_notarget_unknown_post;
+	int HP_skill_cleartimerskill_unknown_pre;
+	int HP_skill_cleartimerskill_unknown_post;
+	int HP_skill_castend_id_unknown_pre;
+	int HP_skill_castend_id_unknown_post;
+	int HP_skill_castend_nodamage_id_dead_unknown_pre;
+	int HP_skill_castend_nodamage_id_dead_unknown_post;
+	int HP_skill_castend_nodamage_id_undead_unknown_pre;
+	int HP_skill_castend_nodamage_id_undead_unknown_post;
+	int HP_skill_castend_nodamage_id_mado_unknown_pre;
+	int HP_skill_castend_nodamage_id_mado_unknown_post;
+	int HP_skill_castend_nodamage_id_unknown_pre;
+	int HP_skill_castend_nodamage_id_unknown_post;
+	int HP_skill_castend_pos2_effect_unknown_pre;
+	int HP_skill_castend_pos2_effect_unknown_post;
+	int HP_skill_castend_pos2_unknown_pre;
+	int HP_skill_castend_pos2_unknown_post;
+	int HP_skill_unitsetting1_unknown_pre;
+	int HP_skill_unitsetting1_unknown_post;
+	int HP_skill_unitsetting2_unknown_pre;
+	int HP_skill_unitsetting2_unknown_post;
+	int HP_skill_unit_onplace_unknown_pre;
+	int HP_skill_unit_onplace_unknown_post;
+	int HP_skill_check_condition_castbegin_off_unknown_pre;
+	int HP_skill_check_condition_castbegin_off_unknown_post;
+	int HP_skill_check_condition_castbegin_mount_unknown_pre;
+	int HP_skill_check_condition_castbegin_mount_unknown_post;
+	int HP_skill_check_condition_castbegin_madogear_unknown_pre;
+	int HP_skill_check_condition_castbegin_madogear_unknown_post;
+	int HP_skill_check_condition_castbegin_unknown_pre;
+	int HP_skill_check_condition_castbegin_unknown_post;
+	int HP_skill_check_condition_castend_unknown_pre;
+	int HP_skill_check_condition_castend_unknown_post;
+	int HP_skill_get_requirement_off_unknown_pre;
+	int HP_skill_get_requirement_off_unknown_post;
+	int HP_skill_get_requirement_item_unknown_pre;
+	int HP_skill_get_requirement_item_unknown_post;
+	int HP_skill_get_requirement_unknown_pre;
+	int HP_skill_get_requirement_unknown_post;
 	int HP_status_init_pre;
 	int HP_status_init_post;
 	int HP_status_final_pre;
diff --git a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
index 89ded9041..d83b398eb 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.HookingPoints.inc
@@ -87,6 +87,10 @@ struct HookingPointData HookingPoints[] = {
 	{ HP_POP(battle->config_adjust, HP_battle_config_adjust) },
 	{ HP_POP(battle->get_enemy_area, HP_battle_get_enemy_area) },
 	{ HP_POP(battle->damage_area, HP_battle_damage_area) },
+	{ HP_POP(battle->calc_masteryfix_unknown, HP_battle_calc_masteryfix_unknown) },
+	{ HP_POP(battle->calc_skillratio_magic_unknown, HP_battle_calc_skillratio_magic_unknown) },
+	{ HP_POP(battle->calc_skillratio_weapon_unknown, HP_battle_calc_skillratio_weapon_unknown) },
+	{ HP_POP(battle->calc_misc_attack_unknown, HP_battle_calc_misc_attack_unknown) },
 /* bg */
 	{ HP_POP(bg->init, HP_bg_init) },
 	{ HP_POP(bg->final, HP_bg_final) },
@@ -2391,6 +2395,38 @@ struct HookingPointData HookingPoints[] = {
 	{ HP_POP(skill->cooldown_save, HP_skill_cooldown_save) },
 	{ HP_POP(skill->get_new_group_id, HP_skill_get_new_group_id) },
 	{ HP_POP(skill->check_shadowform, HP_skill_check_shadowform) },
+	{ HP_POP(skill->castend_damage_id_unknown, HP_skill_castend_damage_id_unknown) },
+	{ HP_POP(skill->additional_effect_unknown, HP_skill_additional_effect_unknown) },
+	{ HP_POP(skill->counter_additional_effect_unknown, HP_skill_counter_additional_effect_unknown) },
+	{ HP_POP(skill->attack_combo1_unknown, HP_skill_attack_combo1_unknown) },
+	{ HP_POP(skill->attack_combo2_unknown, HP_skill_attack_combo2_unknown) },
+	{ HP_POP(skill->attack_display_unknown, HP_skill_attack_display_unknown) },
+	{ HP_POP(skill->attack_copy_unknown, HP_skill_attack_copy_unknown) },
+	{ HP_POP(skill->attack_dir_unknown, HP_skill_attack_dir_unknown) },
+	{ HP_POP(skill->attack_blow_unknown, HP_skill_attack_blow_unknown) },
+	{ HP_POP(skill->attack_post_unknown, HP_skill_attack_post_unknown) },
+	{ HP_POP(skill->timerskill_dead_unknown, HP_skill_timerskill_dead_unknown) },
+	{ HP_POP(skill->timerskill_target_unknown, HP_skill_timerskill_target_unknown) },
+	{ HP_POP(skill->timerskill_notarget_unknown, HP_skill_timerskill_notarget_unknown) },
+	{ HP_POP(skill->cleartimerskill_unknown, HP_skill_cleartimerskill_unknown) },
+	{ HP_POP(skill->castend_id_unknown, HP_skill_castend_id_unknown) },
+	{ HP_POP(skill->castend_nodamage_id_dead_unknown, HP_skill_castend_nodamage_id_dead_unknown) },
+	{ HP_POP(skill->castend_nodamage_id_undead_unknown, HP_skill_castend_nodamage_id_undead_unknown) },
+	{ HP_POP(skill->castend_nodamage_id_mado_unknown, HP_skill_castend_nodamage_id_mado_unknown) },
+	{ HP_POP(skill->castend_nodamage_id_unknown, HP_skill_castend_nodamage_id_unknown) },
+	{ HP_POP(skill->castend_pos2_effect_unknown, HP_skill_castend_pos2_effect_unknown) },
+	{ HP_POP(skill->castend_pos2_unknown, HP_skill_castend_pos2_unknown) },
+	{ HP_POP(skill->unitsetting1_unknown, HP_skill_unitsetting1_unknown) },
+	{ HP_POP(skill->unitsetting2_unknown, HP_skill_unitsetting2_unknown) },
+	{ HP_POP(skill->unit_onplace_unknown, HP_skill_unit_onplace_unknown) },
+	{ HP_POP(skill->check_condition_castbegin_off_unknown, HP_skill_check_condition_castbegin_off_unknown) },
+	{ HP_POP(skill->check_condition_castbegin_mount_unknown, HP_skill_check_condition_castbegin_mount_unknown) },
+	{ HP_POP(skill->check_condition_castbegin_madogear_unknown, HP_skill_check_condition_castbegin_madogear_unknown) },
+	{ HP_POP(skill->check_condition_castbegin_unknown, HP_skill_check_condition_castbegin_unknown) },
+	{ HP_POP(skill->check_condition_castend_unknown, HP_skill_check_condition_castend_unknown) },
+	{ HP_POP(skill->get_requirement_off_unknown, HP_skill_get_requirement_off_unknown) },
+	{ HP_POP(skill->get_requirement_item_unknown, HP_skill_get_requirement_item_unknown) },
+	{ HP_POP(skill->get_requirement_unknown, HP_skill_get_requirement_unknown) },
 /* status */
 	{ HP_POP(status->init, HP_status_init) },
 	{ HP_POP(status->final, HP_status_final) },
@@ -2586,4 +2622,4 @@ struct HookingPointData HookingPoints[] = {
 	{ HP_POP(vending->searchall, HP_vending_searchall) },
 };
 
-int HookingPointsLenMax = 41;
+int HookingPointsLenMax = 49;
diff --git a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
index ff08b8909..3249949e7 100644
--- a/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
+++ b/src/plugins/HPMHooking/HPMHooking_map.Hooks.inc
@@ -2217,6 +2217,110 @@ int HP_battle_damage_area(struct block_list *bl, va_list ap) {
 	}
 	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;
+}
 /* bg */
 void HP_bg_init(bool minimal) {
 	int hIndex = 0;
@@ -63364,6 +63468,854 @@ bool HP_skill_check_shadowform(struct block_list *bl, int64 damage, int 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 block_list *target, 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 block_list *target, 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, target, ud, skl);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.timerskill_notarget_unknown(tid, tick, src, target, ud, skl);
+	}
+	if( HPMHooks.count.HP_skill_timerskill_notarget_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_notarget_unknown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_timerskill_notarget_unknown_post[hIndex].func;
+			postHookFunc(&tid, &tick, src, target, ud, skl);
+		}
+	}
+	return;
+}
+void HP_skill_cleartimerskill_unknown(int skill_id) {
+	int hIndex = 0;
+	if( HPMHooks.count.HP_skill_cleartimerskill_unknown_pre ) {
+		void (*preHookFunc) (int *skill_id);
+		*HPMforce_return = false;
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_unknown_pre; hIndex++ ) {
+			preHookFunc = HPMHooks.list.HP_skill_cleartimerskill_unknown_pre[hIndex].func;
+			preHookFunc(&skill_id);
+		}
+		if( *HPMforce_return ) {
+			*HPMforce_return = false;
+			return;
+		}
+	}
+	{
+		HPMHooks.source.skill.cleartimerskill_unknown(skill_id);
+	}
+	if( HPMHooks.count.HP_skill_cleartimerskill_unknown_post ) {
+		void (*postHookFunc) (int *skill_id);
+		for(hIndex = 0; hIndex < HPMHooks.count.HP_skill_cleartimerskill_unknown_post; hIndex++ ) {
+			postHookFunc = HPMHooks.list.HP_skill_cleartimerskill_unknown_post[hIndex].func;
+			postHookFunc(&skill_id);
+		}
+	}
+	return;
+}
+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___;
+}
+int 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;
+	int retVal___ = 0;
+	if( HPMHooks.count.HP_skill_get_requirement_item_unknown_pre ) {
+		int (*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 ) {
+		int (*postHookFunc) (int 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;
+}
 /* status */
 int HP_status_init(bool minimal) {
 	int hIndex = 0;