#pragma once

#include <basis/seadTypes.h>
#include <math/seadMatrix.h>
#include <math/seadVector.h>
#include <prim/seadSafeString.h>

namespace al {
class ComboCounter;
class EventFlowExecutor;
class HitSensor;
class LiveActor;
class MtxConnector;
class ParabolicPath;
class SensorMsg;
class ScreenPointer;
class ScreenPointTarget;
}  // namespace al

namespace sead {
class Color4u8;
}  // namespace sead

class CapTargetInfo;
class ComboCounter;
class DigPoint;
class FishingFish;
class GotogotonMark;
class HackEndParam;
class IUsePlayerHack;
class SaveObjInfo;
class TouchTargetInfo;
class WhipTargetInfo;

namespace rs {

bool sendMsgAckCheckpoint(al::HitSensor* source, al::HitSensor* target);
bool sendMsgAckGetShine(al::HitSensor* source, al::HitSensor* target);
bool sendMsgAckLifeUp(al::HitSensor* source, al::HitSensor* target);
bool sendMsgAckLifeMaxUp(al::HitSensor* source, al::HitSensor* target);
bool sendMsgAskRailCollision(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBreakPartsBreak(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBirdFlyAway(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCameraAngleElevationResetFast(al::HitSensor* source, al::HitSensor* target);
bool sendMsgChorobonAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgConductLightning(al::HitSensor* source, al::HitSensor* target);
bool sendMsgDamageBallAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgDamageBallBodyAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgDonsukeAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgDonsukeGroundAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgDonsukePush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgDragonAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEatExplosion(al::HitSensor* source, al::HitSensor* target);
bool sendMsgElectricWireNoLimitDistance(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyAttack2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyAttack3D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyAttackDash(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackAttackFire(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyAttackFireCollision(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyAttackPoison(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyAttackTRex(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackAttackPoison(al::HitSensor* source, al::HitSensor* target);
bool sendMsgConfirmPaintObj(al::HitSensor* source, al::HitSensor* target);
bool sendMsgConfirmPaintObjForSeed(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPaintAttackPoison(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyKick(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRabbitKick(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFishingAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFishingCancel(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFishingFishApproach(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFishingFishFloatTouch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFishingItemGet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFishingLineTouch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFishingStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFishingUpImmediatelyPrepare(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFireBrosFireBallCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFireSwitchFire(al::HitSensor* source, al::HitSensor* target);
bool sendMsgFrogHackTrample(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGhostRecordStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGhostRecordEnd(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGhostPlay(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGhostStop(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGiantWanderBossAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGiantWanderBossBulletAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGiantWanderBossBulletPush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGhostReverse(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGhostCancel(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGrowFlowerSeedDisablePush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGrowFlowerSeedNear(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGrowPlantPush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGrowerAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGrowerWallAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGunetterAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGunetterBodyTouch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHammerAttackDown(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHammerAttackSide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHammerAttackSideCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgItemAmiiboKoopa(al::HitSensor* source, al::HitSensor* target);
bool sendMsgIsExistPukupuku(al::HitSensor* source, al::HitSensor* target);
bool sendMsgJangoAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgJangoRemoveCap(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKakkuKick(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillByBossBattleDemo(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillByHackFirstDemo(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillByHomeDemo(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEndHomeDemo(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillByMoonRockDemo(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillByShineGet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillBySwitchTimer(al::LiveActor*);
bool sendMsgKoopaBindStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPlayerFocusTarget(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPunchFinishL(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPunchFinishR(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPunchInvincibleL(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPunchInvincibleR(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPunchKnockBackL(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPunchKnockBackR(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPunchL(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapPunchR(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCapSpinAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaCatchKoopaCap(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaDashPunchAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaFire2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaFireBallAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaHackDamage(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaHackPunch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaHackPunchCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaHackTrample(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaInvalidHackPunchFaceToCollision(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaRingBeamInvalidTouch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaTailAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKoopaTouchFloor(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKouraAttack2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKouraItemGet2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgLaunchBlow(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMeganeAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMeganeHackTrample(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMofumofuBulletUnexplosion(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMoonBasementAttackMeteor(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMoonBasementBreakShockwaveMeteor(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMoonBasementRockSyncClippingRegist(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMoonBasementRockSyncClippingInvalidate(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMoonBasementRockSyncClippingValidate(al::HitSensor* source, al::HitSensor* target);
bool sendMsgAttachCactusNeedle(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCactusNeedleAttack(al::HitSensor* source, al::HitSensor* target, al::ComboCounter*);
bool sendMsgCactusNeedleAttackStrong(al::HitSensor* source, al::HitSensor* target,
                                     al::ComboCounter*);
bool sendMsgPlayerBallToss(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCarryCameraSubjectiveStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCarryCameraSubjectiveEnd(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCarryShineGetStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCarryShineGetEnd(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCapCatch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCapHipDrop(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCapPush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCapRecovery(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCapTouchJump(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCapTrample(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerCoinDashGet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerEyePriorityTarget(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerDisregardHomingAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerDisregardTargetMarker(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerEquipKoopaCap(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerFireBallAttack2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerFireBallAttack3D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerHipDropDemoTrigger(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerHipDropHipDropSwitch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerItemGet2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerJumpTakeOffFloor(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerObjectWallHit(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerObjLeapFrog(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerPenguinAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerPenguinAttackReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerPoleClimbKeep(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerPoleClimbReaction(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerRabbitGet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerRollingObjHit(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerRollingWallHitDown(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerRollingWallHitMove(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerStartGrabCeil(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerStartWallJump(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerEndGrabCeil(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerSwordAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerTouchFloorJumpCode(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerTrample2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerUpperPunch2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerObjUpperPunch2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPukupukuDash(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPukupukuKiss(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPukupukuRollingAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPush2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPushToFish(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPushToMotorcycle(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPushToPlayer(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRadishAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRadishReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRequestChangeKinokoSuper(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRequestChangeFireFlower(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRequestPlayerSandMoon(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRequestPlayerSnow(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRequestPlayerWet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgStartHack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSunshineAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCancelHack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCancelHackArea(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCancelHackByDokan(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPackunEatStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackAttackKick(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackAttackMapObj(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackDeathAreaSelfCheck(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackDemoEnd(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackDemoStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackInvalidEscape(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackInvalidEscapeNoReaction(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackMarioCheckpointFlagWarp(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackMarioDead(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackMarioDemo(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackMarioInWater(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackMoveRockForestPush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackSelfCeilingCheckMiss(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackSyncDamageVisibility(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWeaponItemGet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapAttackCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapAttackStayRolling(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapAttackStayRollingCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapAttackRailMove(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapGiantAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapReflectCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapStartLockOn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapKeepLockOn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapCancelLockOn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapHipDrop(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapObjHipDrop(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapObjHipDropReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapIgnoreCancelLockOn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapIgnoreCancelMissReaction(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapIgnoreCollisionCheck(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapItemGet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCapTrampolineAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCatchBombThrough(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCheckCarObstacle(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCheckIsCardboardBox(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBullHackAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBullEnemyAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyAttackStrong(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnemyObjBreak(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWhipAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgNoLimitTouchJump(al::HitSensor* source, al::HitSensor* target);
bool sendMsgNoticePlayerDamage(al::HitSensor* source, al::HitSensor* target);
bool sendMsgStatueDrop(al::HitSensor* source, al::HitSensor* target);
bool sendMsgStatueTrampleReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgStatuePush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgStatueSnap(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHitGrowFlowerPot(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHitGrowPlantPot(al::HitSensor* source, al::HitSensor* target);
bool sendMsgImplantGrowFlowerSeed(al::HitSensor* source, al::HitSensor* target);
bool sendMsgIcicleAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgIgnoreMirrorWarp(al::HitSensor* source, al::HitSensor* target);
bool sendMsgIgnoredByRunawayNpc(al::HitSensor* source, al::HitSensor* target);
bool sendMsgIgnorePushMotorcycle(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSandSharkAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSeedAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSeedAttackBig(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSeedAttackHold(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSeedItemGet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSeedReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSenobiTrample(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSenobiCancelStretch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSenobiPunchBlockTransparent(al::HitSensor* source, al::HitSensor* target);
bool sendMsgShibakenApproach(al::HitSensor* source, al::HitSensor* target);
bool sendMsgShibakenKick(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackUpperPunch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackObjUpperPunch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgShineGet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgShineGet2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSpherePush(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32);
bool sendMsgSphinxJumpAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSphinxQuizRouteKill(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSphinxRideAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSphinxRideAttackReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPechoSpot(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBelowObjBroken(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBindCollidedGround(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBindKeepDemoStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBindKeepDemoExecute(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBindKeepDemoEnd(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBindRecoveryLife(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMayorItemReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMayorItemCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBlowObjAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBlowObjAttackReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgConfirmFrailBox(al::HitSensor* source, al::HitSensor* target);
bool sendMsgConfirmBrokenFrailBox(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTankLookOn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTankKickHack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTankKickEnemy(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTankBullet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTankBulletNoReaction(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTimerAthleticDemoStart(al::LiveActor*);
bool sendMsgRideOnStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRideOnEnd(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRideOnRelease(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHipDropTransformTransform(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHipDropTransformReverse(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHipDropTransformingUp(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHipDropTransformingDown(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHipDropTransformingFinish(al::HitSensor* source, al::HitSensor* target);
bool sendMsgClearFire(al::HitSensor* source, al::HitSensor* target);
bool sendMsgCollectAnimalTouchCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossKnuckleCounter(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossKnuckleFallAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossKnuckleHackAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossKnuckleKillerAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossKnuckleIceConflict(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossKnuckleIceFallToMummy(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSkaterAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnableInSaucePan(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEnableMapCheckPointWarp(al::HitSensor* source, al::HitSensor* target);
bool sendMsgStartInSaucePan(al::HitSensor* source, al::HitSensor* target, bool);
bool sendMsgEndInSaucePan(al::HitSensor* source, al::HitSensor* target);
bool sendMsgLineDancerLink(al::HitSensor* source, al::HitSensor* target);
bool sendMsgLongPushSensorHit(al::HitSensor* source, al::HitSensor* target);
bool sendMsgLongPushBoxHit(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGoldHammerAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTrashBoxIn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTouchDoorDrumn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKuribo2DTouch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKuriboCollisionDamage(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKuriboCollisionKill(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKuriboFlick(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKuriboTowerOn(al::HitSensor* source, al::HitSensor* target, u32);
bool sendMsgPartyPopperSoundAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgYokinBallAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgYoshiDirectEat(al::HitSensor* source, al::HitSensor* target);
bool sendMsgYoshiTongueAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgYoshiTongueEatBind(al::HitSensor* source, al::HitSensor* target, f32*, f32*, f32*);
bool sendMsgYoshiTongueEatBindCancel(al::HitSensor* source, al::HitSensor* target);
bool sendMsgYoshiTongueEatBindFinish(al::HitSensor* source, al::HitSensor* target);
bool sendMsgYoshiTongueEatHomingTarget(al::HitSensor* source, al::HitSensor* target);
bool sendMsgYukimaruPush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPunchMachinePunchStraight(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPunchMachinePunchHook(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPunchMachinePunchUpper(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMorningStarWarpStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMorningStarWarpEnd(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGemyAim(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHammerBrosHammerEnemyAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHammerBrosHammerHackAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHammerBrosHammerSearch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHackBrosContact(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMotorcycleAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMotorcycleCollideParkingLot(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMotorcycleDashAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgMotorcycleDashCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWanwanEnemyAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWanwanPush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWanwanReboundAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWanwanBlockAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWanwanHoleIn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWaterRoadIn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWaterRoadNear(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBreedaSlap(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBreedaPush(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGamaneBullet(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGamaneBulletThrough(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGamaneBulletForCoinFlower(al::HitSensor* source, al::HitSensor* target);
bool sendMsgVolleyballNpcScareByEnemy(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRocketFlowerExtension(al::HitSensor* source, al::HitSensor* target);
bool sendMsgWanderBossCameraRange(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKuriboGirlAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKuriboGirlLove(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKuriboTop(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTRexAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTRexAttackCollideBody(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTRexAttackCollideHead(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTRexDashAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTRexScrollPartsBreakWith(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTsukkunNoTrace(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTouchFireDrum2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPropellerAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTankExplosion(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTankHackTrample(al::HitSensor* source, al::HitSensor* target);
bool sendMsgUtsuboAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillerAttackNoExplode(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillerMagnumAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgKillerMagnumHackAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGabuzouAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgStackerRollingAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgStackerCapBoostAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgIgnoreIgnitionBomb(al::HitSensor* source, al::HitSensor* target);
bool sendMsgExplosionReflectBomb(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGolemStampPress(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSwitchOnWithSaveRequest(al::LiveActor*, SaveObjInfo*);
bool sendMsgWanwanReboundAttackToCollided(const al::LiveActor*, al::HitSensor*);
bool sendMsgWanwanBlockAttackToCollided(const al::LiveActor*, al::HitSensor*);
bool sendMsgDigPointSmell(al::HitSensor* source, al::HitSensor* target, DigPoint*);
bool sendMsgMofumofuBodyChainExplode(al::HitSensor* source, al::HitSensor* target, s32);
bool sendMsgMoonBasementRockThroughCollision(al::HitSensor* source, al::HitSensor* target, bool);
bool sendMsgFishingWait(al::HitSensor* source, al::HitSensor* target, al::HitSensor*);
bool sendMsgFishingUpImmediately(al::HitSensor* source, al::HitSensor* target,
                                 const sead::Matrix34f&, const sead::Vector3f&, const char*);
bool sendMsgGunetterPush(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32);
bool sendMsgTestPunch(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32,
                      s32);
bool sendMsgTestPunchStrong(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                            s32, s32);
bool sendMsgPunchGuard(al::HitSensor* source, al::HitSensor* target, s32, s32);
bool sendMsgTsukkunThrust(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, s32,
                          bool);
bool sendMsgTsukkunThrustSpin(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                              s32, bool);
bool sendMsgTsukkunThrustReflect(al::HitSensor* source, al::HitSensor* target,
                                 const sead::Vector3f&, s32, bool);
bool sendMsgTsukkunThrustCollide(al::HitSensor* source, al::HitSensor* target,
                                 const sead::Vector3f&, s32, bool);
bool sendMsgTsukkunThrustHitReflectCollide(al::HitSensor* source, al::HitSensor* target,
                                           const sead::Vector3f&, s32, bool);
bool sendMsgTsukkunThrustReflectCollide(al::HitSensor* source, al::HitSensor* target,
                                        const sead::Vector3f&, s32, bool);
bool sendMsgTsukkunThrustHole(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                              const sead::Vector3f&);
bool sendMsgTsukkunThroughCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTsukkunHoldCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTsukkunForceCancelCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgNetworkShootingShot(al::HitSensor* source, al::HitSensor* target, s32);
bool sendMsgNetworkShootingChargeShot(al::HitSensor* source, al::HitSensor* target, s32);
bool sendMsgRequestPlayerJumpBreakFloor(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRequestPlayerJump(al::HitSensor* source, al::HitSensor* target, f32);
bool sendMsgRequestPlayerTrampleJump(al::HitSensor* source, al::HitSensor* target, f32);
bool sendMsgRequestPlayerSpinJump(al::HitSensor* source, al::HitSensor* target, f32);
bool sendMsgRequestSphinxJump(al::HitSensor* source, al::HitSensor* target, f32);
bool sendMsgIgnoreTouchTarget(al::HitSensor* source, al::HitSensor* target);
bool sendMsgIgnoreTouchTarget(al::ScreenPointer*, al::ScreenPointTarget*);
bool sendMsgInitTouchTargetInfo(al::HitSensor* source, al::HitSensor* target, TouchTargetInfo*,
                                const sead::Vector3f*);
bool sendMsgInitTouchTargetInfo(al::ScreenPointer*, al::ScreenPointTarget*, TouchTargetInfo*,
                                const sead::Vector3f*);
bool sendMsgCollisionImpulse(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*,
                             const sead::Vector3f&, f32, const sead::Vector3f&, f32);
bool sendMsgWhipHold(al::HitSensor* source, al::HitSensor* target, WhipTargetInfo*);
bool sendMsgWhipBind(al::HitSensor* source, al::HitSensor* target, WhipTargetInfo*);
bool sendMsgWhipThrow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&);
bool sendMsgMagnet(al::HitSensor* source, al::HitSensor* target, bool);
bool sendMsgMagnetBulletAttack(al::HitSensor* source, al::HitSensor* target, f32);
bool sendMsgDashPanel(al::HitSensor* source, al::HitSensor* target, s32);
bool sendMsgTrampolineCrackJump(al::HitSensor* source, al::HitSensor* target, f32, f32);
bool sendMsgCapTouchWall(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                         const sead::Vector3f&);
bool sendMsgCapRethrow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                       const sead::Vector3f&, const sead::Vector3f&);
bool sendMsgCapRethrowReturnOnly(al::HitSensor* source, al::HitSensor* target,
                                 const sead::Vector3f&, const sead::Vector3f&,
                                 const sead::Vector3f&);
bool sendMsgCapChangeGiant(al::HitSensor* source, al::HitSensor* target, f32, s32);
bool sendMsgPackunEatCancel(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                            const sead::Vector3f&);
bool sendMsgPackunEatEnd(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                         const sead::Vector3f&);
bool sendMsgPackunEatStartFollow(al::HitSensor* source, al::HitSensor* target,
                                 const sead::Vector3f*);
bool sendMsgFireBlowerAttack(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                             const sead::Vector3f&, f32);
bool sendMsgPaint(al::HitSensor* source, al::HitSensor* target, const sead::Color4u8&, s32, s32);
bool sendMsgPaintTexture(al::HitSensor* source, al::HitSensor* target, s32, f32, s32);
bool sendMsgCheckPaintClear(al::HitSensor* source, al::HitSensor* target, const sead::Color4u8&,
                            const sead::Vector3f&, s32);
bool sendMsgCheckPaintAlpha(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&);
bool sendMsgByugoBlow(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&);
bool sendMsgHackDirectStageInit(al::HitSensor* source, al::HitSensor* target, IUsePlayerHack*);
bool sendMsgObjSnapForce(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&);
bool sendMsgCapBeamerBeam(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHosuiAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHosuiAttackCollide(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHosuiAttackNoEffect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHosuiAttackStrong(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHosuiTouch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHosuiTrample(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHosuiTrampleReflect(al::HitSensor* source, al::HitSensor* target);
bool sendMsgHosuiTrampleReflectHigh(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBubbleAttack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBubbleAttackToPecho(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBubbleReflectH(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBubbleReflectV(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBubbleWallTouch(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBubbleGroundTouchTrigger(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBubbleLauncherStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSenobiPartsMove(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                            f32);
bool sendMsgStampTo2D(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&);
bool sendMsgAirExplosion(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&);
bool sendMsgPushVelocity(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&);
bool sendMsgGhostRecordStartOk(al::HitSensor* source, al::HitSensor* target, const char*);
bool sendMsgSandGeyserRaise(al::HitSensor* source, al::HitSensor* target, f32, f32);
bool sendMsgRaceWait(al::LiveActor*);
bool sendMsgRaceStart(al::LiveActor*);
bool sendMsgRaceStop(al::LiveActor*);
bool sendMsgRaceReturnToCourse(al::LiveActor*, const sead::Vector3f&, const sead::Vector3f&);
bool sendMsgPlayerLookAtPosition(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*);
bool sendMsgTargetMarkerPosition(al::HitSensor* source, al::HitSensor* target, sead::Vector3f*);
bool sendMsgHackBlowJump(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&, f32);
bool sendMsgGolemStampPushV(al::HitSensor* source, al::HitSensor* target, f32);
bool sendMsgGolemStampPushH(al::HitSensor* source, al::HitSensor* target, f32);
bool sendMsgRequestPlayerWaitAnimDigPoint(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEventFlowScareCheck(al::HitSensor* source, al::HitSensor* target,
                                al::EventFlowExecutor*);
bool sendMsgPlayerItemGetAll(al::HitSensor* source, al::HitSensor* target);
bool sendMsgPlayerItemGetAll2D(al::HitSensor* source, al::HitSensor* target);
bool sendMsgTRexAttackAll(al::HitSensor* source, al::HitSensor* target);
bool sendMsgSeedTouch(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&,
                      const sead::Vector3f&);
bool sendMsgSphinxRideAttackTouchThrough(al::HitSensor* source, al::HitSensor* target,
                                         const sead::Vector3f&, const sead::Vector3f&);
bool sendMsgSphinxRideAttackTouch(al::HitSensor* source, al::HitSensor* target,
                                  const sead::Vector3f&, const sead::Vector3f&);

bool isMsgAckCheckpoint(const al::SensorMsg*);
bool isMsgAckGetShine(const al::SensorMsg*);
bool isMsgAckLifeUp(const al::SensorMsg*);
bool isMsgAckLifeMaxUp(const al::SensorMsg*);
bool isMsgAskRailCollision(const al::SensorMsg*);
bool isMsgAttachCactusNeedle(const al::SensorMsg*);
bool isMsgAirExplosion(const al::SensorMsg*);
bool isMsgBelowObjBroken(const al::SensorMsg*);
bool isMsgBindCollidedGround(const al::SensorMsg*);
bool isMsgBindKeepDemoStart(const al::SensorMsg*);
bool isMsgBindKeepDemoExecute(const al::SensorMsg*);
bool isMsgBindKeepDemoEnd(const al::SensorMsg*);
bool isMsgBindRecoveryLife(const al::SensorMsg*);
bool isMsgBirdFlyAway(const al::SensorMsg*);
bool isMsgBlowObjAttack(const al::SensorMsg*);
bool isMsgMayorItemCollide(const al::SensorMsg*);
bool isMsgMayorItemReflect(const al::SensorMsg*);
bool isMsgBlowObjAttackReflect(const al::SensorMsg*);
bool isMsgBossKnuckleCounter(const al::SensorMsg*);
bool isMsgBossKnuckleFallAttack(const al::SensorMsg*);
bool isMsgBossKnuckleHackAttack(const al::SensorMsg*);
bool isMsgBossKnuckleIceConflict(const al::SensorMsg*);
bool isMsgBossKnuckleIceFallToMummy(const al::SensorMsg*);
bool isMsgBossKnuckleKillerAttack(const al::SensorMsg*);
bool isMsgBreakPartsBreak(const al::SensorMsg*);
bool isMsgBreedaSlap(const al::SensorMsg*);
bool isMsgBreedaPush(const al::SensorMsg*);
bool isMsgBubbleAttack(const al::SensorMsg*);
bool isMsgBubbleAttackToPecho(const al::SensorMsg*);
bool isMsgBubbleLauncherStart(const al::SensorMsg*);
bool isMsgBubbleReflectH(const al::SensorMsg*);
bool isMsgBubbleReflectV(const al::SensorMsg*);
bool isMsgBubbleWallTouch(const al::SensorMsg*);
bool isMsgBubbleGroundTouchTrigger(const al::SensorMsg*);
bool isMsgBullAttack(const al::SensorMsg*);
bool isMsgBullHackAttack(const al::SensorMsg*);
bool isMsgBullEnemyAttack(const al::SensorMsg*);
bool isMsgByugoBlow(const al::SensorMsg*);
bool isMsgCameraAngleElevationResetFast(const al::SensorMsg*);
bool isMsgCancelHack(const al::SensorMsg*);
bool isMsgCancelHackArea(const al::SensorMsg*);
bool isMsgCancelHackByDokan(const al::SensorMsg*);
bool isMsgCapAttack(const al::SensorMsg*);
bool isMsgCapAttackCollide(const al::SensorMsg*);
bool isMsgCapAttackRailMove(const al::SensorMsg*);
bool isMsgCapAttackStayRolling(const al::SensorMsg*);
bool isMsgCapAttackStayRollingCollide(const al::SensorMsg*);
bool isMsgCapBeamerBeam(const al::SensorMsg*);
bool isMsgCapCancelLockOn(const al::SensorMsg*);
bool isMsgCapChangeGiant(const al::SensorMsg*);
bool isMsgCapEnableLockOn(const al::SensorMsg*);
bool isMsgCapStartLockOn(const al::SensorMsg*);
bool isMsgCapKeepLockOn(const al::SensorMsg*);
bool isMsgCapGiantAttack(const al::SensorMsg*);
bool isMsgCapHipDrop(const al::SensorMsg*);
bool isMsgCapObjHipDrop(const al::SensorMsg*);
bool isMsgCapObjHipDropReflect(const al::SensorMsg*);
bool isMsgCapIgnoreCancelLockOn(const al::SensorMsg*);
bool isMsgCapIgnoreCancelMissReaction(const al::SensorMsg*);
bool isMsgCapIgnoreCollisionCheck(const al::SensorMsg*);
bool isMsgCapItemGet(const al::SensorMsg*);
bool isMsgCapReflect(const al::SensorMsg*);
bool isMsgCapReflectCollide(const al::SensorMsg*);
bool isMsgCapRethrow(const al::SensorMsg*);
bool isMsgCapTouchWall(const al::SensorMsg*);
bool isMsgCapTrampolineAttack(const al::SensorMsg*);
bool isMsgCatchBombThrough(const al::SensorMsg*);
bool isMsgCheckCarObstacle(const al::SensorMsg*);
bool isMsgCheckIsCardboardBox(const al::SensorMsg*);
bool isMsgChorobonAttack(const al::SensorMsg*);
bool isMsgClearFire(const al::SensorMsg*);
bool isMsgCollectAnimalTouchCollide(const al::SensorMsg*);
bool isMsgCollisionImpulse(const al::SensorMsg*);
bool isMsgConductLightning(const al::SensorMsg*);
bool isMsgConfirmFrailBox(const al::SensorMsg*);
bool isMsgConfirmBrokenFrailBox(const al::SensorMsg*);
bool isMsgDamageBallAttack(const al::SensorMsg*);
bool isMsgDamageBallBodyAttack(const al::SensorMsg*);
bool isMsgDigPointSmell(const al::SensorMsg*);
bool isMsgDonsukeAttack(const al::SensorMsg*);
bool isMsgDonsukeGroundAttack(const al::SensorMsg*);
bool isMsgDonsukePush(const al::SensorMsg*);
bool isMsgDragonAttack(const al::SensorMsg*);
bool isMsgEatExplosion(const al::SensorMsg*);
bool isMsgElectricWireNoLimitDistance(const al::SensorMsg*);
bool isMsgEnableInSaucePan(const al::SensorMsg*);
bool isMsgEnableMapCheckPointWarp(const al::SensorMsg*);
bool isMsgEndInSaucePan(const al::SensorMsg*);
bool isMsgEnemyAttack2D(const al::SensorMsg*);
bool isMsgEnemyAttack3D(const al::SensorMsg*);
bool isMsgEnemyAttackDash(const al::SensorMsg*);
bool isMsgFireBrosFireBallCollide(const al::SensorMsg*);
bool isMsgFireDamageAll(const al::SensorMsg*);
bool isMsgHackAttackFire(const al::SensorMsg*);
bool isMsgFireSwitchFire(const al::SensorMsg*);
bool isMsgEnemyAttackFireCollision(const al::SensorMsg*);
bool isMsgEnemyAttackTRex(const al::SensorMsg*);
bool isMsgPoisonDamageAll(const al::SensorMsg*);
bool isMsgEnemyAttackPoison(const al::SensorMsg*);
bool isMsgHackAttackPoison(const al::SensorMsg*);
bool isMsgPaintAttackPoison(const al::SensorMsg*);
bool isMsgConfirmPaintObj(const al::SensorMsg*);
bool isMsgConfirmPaintObjForSeed(const al::SensorMsg*);
bool isMsgEnemyAttackStrong(const al::SensorMsg*);
bool isMsgEnemyKick(const al::SensorMsg*);
bool isMsgRabbitKick(const al::SensorMsg*);
bool isMsgEnemyObjBreak(const al::SensorMsg*);
bool isMsgFireBlowerAttack(const al::SensorMsg*);
bool isMsgFishingAttack(const al::SensorMsg*);
bool isMsgFishingCancel(const al::SensorMsg*);
bool isMsgFishingFishApproach(const al::SensorMsg*);
bool isMsgFishingFishFloatTouch(const al::SensorMsg*);
bool isMsgFishingItemGet(const al::SensorMsg*);
bool isMsgFishingLineTouch(const al::SensorMsg*);
bool isMsgFishingStart(const al::SensorMsg*);
bool isMsgFishingUpImmediately(const al::SensorMsg*);
bool isMsgFishingUpImmediatelyPrepare(const al::SensorMsg*);
bool isMsgFishingWait(const al::SensorMsg*);
bool isMsgFrogHackTrample(const al::SensorMsg*);
bool isMsgGamaneBullet(const al::SensorMsg*);
bool isMsgGamaneBulletThrough(const al::SensorMsg*);
bool isMsgGamaneBulletForCoinFlower(const al::SensorMsg*);
bool isMsgGemyAim(const al::SensorMsg*);
bool isMsgGhostCancel(const al::SensorMsg*);
bool isMsgGhostPlay(const al::SensorMsg*);
bool isMsgGhostRecordEnd(const al::SensorMsg*);
bool isMsgGhostRecordStart(const al::SensorMsg*);
bool isMsgGhostRecordStartOk(const al::SensorMsg*);
bool isMsgGhostReverse(const al::SensorMsg*);
bool isMsgGhostStop(const al::SensorMsg*);
bool isMsgGiantWanderBossAttack(const al::SensorMsg*);
bool isMsgGiantWanderBossBulletAttack(const al::SensorMsg*);
bool isMsgGiantWanderBossBulletPush(const al::SensorMsg*);
bool isMsgGoldHammerAttack(const al::SensorMsg*);
bool isMsgGrowFlowerSeedDisablePush(const al::SensorMsg*);
bool isMsgGrowFlowerSeedNear(const al::SensorMsg*);
bool isMsgGrowPlantPush(const al::SensorMsg*);
bool isMsgGrowerAttack(const al::SensorMsg*);
bool isMsgGrowerWallAttack(const al::SensorMsg*);
bool isMsgGunetterAttack(const al::SensorMsg*);
bool isMsgGunetterBodyTouch(const al::SensorMsg*);
bool isMsgGunetterPush(const al::SensorMsg*);
bool isMsgHackAttack(const al::SensorMsg*);
bool isMsgHackAttackKick(const al::SensorMsg*);
bool isMsgHackAttackMapObj(const al::SensorMsg*);
bool isMsgHackBrosContact(const al::SensorMsg*);
bool isMsgHackDeathAreaSelfCheck(const al::SensorMsg*);
bool isMsgHackDemoEnd(const al::SensorMsg*);
bool isMsgHackDemoStart(const al::SensorMsg*);
bool isMsgHackInvalidEscape(const al::SensorMsg*);
bool isMsgHackInvalidEscapeNoReaction(const al::SensorMsg*);
bool isMsgHackMarioCheckpointFlagWarp(const al::SensorMsg*);
bool isMsgHackMarioDead(const al::SensorMsg*);
bool isMsgHackMarioDemo(const al::SensorMsg*);
bool isMsgHackMarioInWater(const al::SensorMsg*);
bool isMsgHackMoveRockForestPush(const al::SensorMsg*);
bool isMsgHackSelfCeilingCheckMiss(const al::SensorMsg*);
bool isMsgHackSyncDamageVisibility(const al::SensorMsg*);
bool isMsgHackUpperPunch(const al::SensorMsg*);
bool isMsgHackObjUpperPunch(const al::SensorMsg*);
bool isMsgHammerAttackDown(const al::SensorMsg*);
bool isMsgHammerAttackSide(const al::SensorMsg*);
bool isMsgHammerAttackSideCollide(const al::SensorMsg*);
bool isMsgHammerBrosHammerEnemyAttack(const al::SensorMsg*);
bool isMsgHammerBrosHammerHackAttack(const al::SensorMsg*);
bool isMsgHammerBrosHammerSearch(const al::SensorMsg*);
bool isMsgHipDropTransformReverse(const al::SensorMsg*);
bool isMsgHipDropTransformTransform(const al::SensorMsg*);
bool isMsgHipDropTransformingUp(const al::SensorMsg*);
bool isMsgHipDropTransformingDown(const al::SensorMsg*);
bool isMsgHipDropTransformingFinish(const al::SensorMsg*);
bool isMsgHitGrowFlowerPot(const al::SensorMsg*);
bool isMsgHitGrowPlantPot(const al::SensorMsg*);
bool isMsgHosuiAttack(const al::SensorMsg*);
bool isMsgHosuiAttackCollide(const al::SensorMsg*);
bool isMsgHosuiAttackNoEffect(const al::SensorMsg*);
bool isMsgHosuiAttackStrong(const al::SensorMsg*);
bool isMsgHosuiTouch(const al::SensorMsg*);
bool isMsgHosuiTrample(const al::SensorMsg*);
bool isMsgHosuiTrampleReflect(const al::SensorMsg*);
bool isMsgHosuiTrampleReflectHigh(const al::SensorMsg*);
bool isMsgIgnoreTouchTarget(const al::SensorMsg*);
bool isMsgIgnorePushMotorcycle(const al::SensorMsg*);
bool isMsgIcicleAttack(const al::SensorMsg*);
bool isMsgIgnoreMirrorWarp(const al::SensorMsg*);
bool isMsgIgnoredByRunawayNpc(const al::SensorMsg*);
bool isMsgImplantGrowFlowerSeed(const al::SensorMsg*);
bool isMsgInitTouchTargetInfo(const al::SensorMsg*);
bool isMsgItemAmiiboKoopa(const al::SensorMsg*);
bool isMsgIsExistPukupuku(const al::SensorMsg*);
bool isMsgJangoAttack(const al::SensorMsg*);
bool isMsgJangoRemoveCap(const al::SensorMsg*);
bool isMsgKakkuKick(const al::SensorMsg*);
bool isMsgKoopaBindStart(const al::SensorMsg*);
bool isMsgKoopaCapPlayerFocusTarget(const al::SensorMsg*);
bool isMsgKoopaCapPunchFinishL(const al::SensorMsg*);
bool isMsgKoopaCapPunchFinishR(const al::SensorMsg*);
bool isMsgKoopaCapPunchInvincibleL(const al::SensorMsg*);
bool isMsgKoopaCapPunchInvincibleR(const al::SensorMsg*);
bool isMsgKoopaCapPunchKnockBackL(const al::SensorMsg*);
bool isMsgKoopaCapPunchKnockBackR(const al::SensorMsg*);
bool isMsgKoopaCapPunchL(const al::SensorMsg*);
bool isMsgKoopaCapPunchR(const al::SensorMsg*);
bool isMsgKoopaCapSpinAttack(const al::SensorMsg*);
bool isMsgKoopaCatchKoopaCap(const al::SensorMsg*);
bool isMsgKoopaDashPunchAttack(const al::SensorMsg*);
bool isMsgKoopaFire2D(const al::SensorMsg*);
bool isMsgKoopaFireBallAttack(const al::SensorMsg*);
bool isMsgKoopaHackDamage(const al::SensorMsg*);
bool isMsgKoopaHackPunch(const al::SensorMsg*);
bool isMsgKoopaHackPunchCollide(const al::SensorMsg*);
bool isMsgKoopaHackTrample(const al::SensorMsg*);
bool isMsgKoopaInvalidHackPunchFaceToCollision(const al::SensorMsg*);
bool isMsgKoopaRingBeamInvalidTouch(const al::SensorMsg*);
bool isMsgKoopaTailAttack(const al::SensorMsg*);
bool isMsgKoopaTouchFloor(const al::SensorMsg*);
bool isMsgKouraAttack2D(const al::SensorMsg*);
bool isMsgKouraItemGet2D(const al::SensorMsg*);
bool isMsgKuribo2DTouch(const al::SensorMsg*);
bool isMsgKuriboCollisionDamage(const al::SensorMsg*);
bool isMsgKuriboCollisionKill(const al::SensorMsg*);
bool isMsgKuriboFlick(const al::SensorMsg*);
bool isMsgKuriboGirlAttack(const al::SensorMsg*);
bool isMsgKuriboGirlLove(const al::SensorMsg*);
bool isMsgKuriboTop(const al::SensorMsg*);
bool isMsgKuriboTowerNum(const al::SensorMsg*);
bool isMsgLaunchBlow(const al::SensorMsg*);
bool isMsgLineDancerLink(const al::SensorMsg*);
bool isMsgLongPushSensorHit(const al::SensorMsg*);
bool isMsgLongPushBoxHit(const al::SensorMsg*);
bool isMsgMagnetBulletAttack(const al::SensorMsg*);
bool isMsgMeganeAttack(const al::SensorMsg*);
bool isMsgMeganeHackTrample(const al::SensorMsg*);
bool isMsgMofumofuBodyChainExplode(const al::SensorMsg*);
bool isMsgMofumofuBulletUnexplosion(const al::SensorMsg*);
bool isMsgMoonBasementAttackMeteor(const al::SensorMsg*);
bool isMsgMoonBasementBreakShockwaveMeteor(const al::SensorMsg*);
bool isMsgMoonBasementRockSyncClippingRegist(const al::SensorMsg*);
bool isMsgMoonBasementRockSyncClippingInvalidate(const al::SensorMsg*);
bool isMsgMoonBasementRockSyncClippingValidate(const al::SensorMsg*);
bool isMsgMoonBasementRockThroughCollision(const al::SensorMsg*);
bool isMsgMorningStarWarpEnd(const al::SensorMsg*);
bool isMsgMorningStarWarpStart(const al::SensorMsg*);
bool isMsgMotorcycleAttack(const al::SensorMsg*);
bool isMsgMotorcycleCollideParkingLot(const al::SensorMsg*);
bool isMsgMotorcycleDashAttack(const al::SensorMsg*);
bool isMsgMotorcycleDashCollide(const al::SensorMsg*);
bool isMsgCactusNeedleAttack(const al::SensorMsg*);
bool isMsgCactusNeedleAttackStrong(const al::SensorMsg*);
bool isMsgNoLimitTouchJump(const al::SensorMsg*);
bool isMsgNoticePlayerDamage(const al::SensorMsg*);
bool isMsgNpcScareByEnemy(const al::SensorMsg*);
bool isMsgVolleyballNpcScareByEnemy(const al::SensorMsg*);
bool isMsgObjSnapForce(const al::SensorMsg*);
bool isMsgPackunEatCancel(const al::SensorMsg*);
bool isMsgPackunEatEnd(const al::SensorMsg*);
bool isMsgPackunEatStart(const al::SensorMsg*);
bool isMsgPackunEatStartFollow(const al::SensorMsg*);
bool isMsgPaint(const al::SensorMsg*);
bool isMsgPaintTexture(const al::SensorMsg*);
bool isMsgCheckPaintClear(const al::SensorMsg*);
bool isMsgCheckPaintAlpha(const al::SensorMsg*);
bool isMsgPartyPopperSoundAttack(const al::SensorMsg*);
bool isMsgPechoSpot(const al::SensorMsg*);
bool isMsgPlayerBallToss(const al::SensorMsg*);
bool isMsgPlayerCarryCameraSubjectiveStart(const al::SensorMsg*);
bool isMsgPlayerCarryCameraSubjectiveEnd(const al::SensorMsg*);
bool isMsgPlayerCarryShineGetStart(const al::SensorMsg*);
bool isMsgPlayerCarryShineGetEnd(const al::SensorMsg*);
bool isMsgPlayerCapCatch(const al::SensorMsg*);
bool isMsgPlayerCapHipDrop(const al::SensorMsg*);
bool isMsgPlayerCapPush(const al::SensorMsg*);
bool isMsgPlayerCapRecovery(const al::SensorMsg*);
bool isMsgPlayerCapTouchJump(const al::SensorMsg*);
bool isMsgPlayerCapTrample(const al::SensorMsg*);
bool isMsgPlayerCoinDashGet(const al::SensorMsg*);
bool isMsgPlayerEyePriorityTarget(const al::SensorMsg*);
bool isMsgPlayerDisregardHomingAttack(const al::SensorMsg*);
bool isMsgPlayerDisregardTargetMarker(const al::SensorMsg*);
bool isMsgPlayerEquipKoopaCap(const al::SensorMsg*);
bool isMsgPlayerFireBallAttack2D(const al::SensorMsg*);
bool isMsgPlayerFireBallAttack3D(const al::SensorMsg*);
bool isMsgPlayerHipDropDemoTrigger(const al::SensorMsg*);
bool isMsgPlayerHipDropHipDropSwitch(const al::SensorMsg*);
bool isMsgPlayerItemGet2D(const al::SensorMsg*);
bool isMsgPlayerJumpTakeOffFloor(const al::SensorMsg*);
bool isMsgPlayerObjectWallHit(const al::SensorMsg*);
bool isMsgPlayerObjLeapFrog(const al::SensorMsg*);
bool isMsgPlayerPenguinAttack(const al::SensorMsg*);
bool isMsgPlayerPenguinAttackReflect(const al::SensorMsg*);
bool isMsgPlayerPoleClimbKeep(const al::SensorMsg*);
bool isMsgPlayerPoleClimbReaction(const al::SensorMsg*);
bool isMsgPlayerRabbitGet(const al::SensorMsg*);
bool isMsgPlayerRollingObjHit(const al::SensorMsg*);
bool isMsgPlayerRollingWallHitDown(const al::SensorMsg*);
bool isMsgPlayerRollingWallHitMove(const al::SensorMsg*);
bool isMsgPlayerStartGrabCeil(const al::SensorMsg*);
bool isMsgPlayerStartWallJump(const al::SensorMsg*);
bool isMsgPlayerEndGrabCeil(const al::SensorMsg*);
bool isMsgPlayerSwordAttack(const al::SensorMsg*);
bool isMsgPlayerTouchFloorJumpCode(const al::SensorMsg*);
bool isMsgPlayerTrample2D(const al::SensorMsg*);
bool isMsgPlayerUpperPunch2D(const al::SensorMsg*);
bool isMsgPlayerObjUpperPunch2D(const al::SensorMsg*);
bool isMsgPropellerAttack(const al::SensorMsg*);
bool isMsgPukupukuDash(const al::SensorMsg*);
bool isMsgPukupukuKiss(const al::SensorMsg*);
bool isMsgPukupukuRollingAttack(const al::SensorMsg*);
bool isMsgPunchMachinePunchHook(const al::SensorMsg*);
bool isMsgPunchMachinePunchStraight(const al::SensorMsg*);
bool isMsgPunchMachinePunchUpper(const al::SensorMsg*);
bool isMsgPush2D(const al::SensorMsg*);
bool isMsgPushToFish(const al::SensorMsg*);
bool isMsgPushToMotorcycle(const al::SensorMsg*);
bool isMsgPushToPlayer(const al::SensorMsg*);
bool isMsgRadishAttack(const al::SensorMsg*);
bool isMsgRadishReflect(const al::SensorMsg*);
bool isMsgRaceStart(const al::SensorMsg*);
bool isMsgRaceStop(const al::SensorMsg*);
bool isMsgRaceWait(const al::SensorMsg*);
bool isMsgRequestChangeFireFlower(const al::SensorMsg*);
bool isMsgRequestChangeKinokoSuper(const al::SensorMsg*);
bool isMsgRequestPlayerJumpBreakFloor(const al::SensorMsg*);
bool isMsgRequestPlayerJump(const al::SensorMsg*);
bool isMsgRequestPlayerTrampleJump(const al::SensorMsg*);
bool isMsgRequestPlayerSpinJump(const al::SensorMsg*);
bool isMsgRequestSphinxJump(const al::SensorMsg*);
bool isMsgRideOnEnd(const al::SensorMsg*);
bool isMsgRideOnRelease(const al::SensorMsg*);
bool isMsgRideOnStart(const al::SensorMsg*);
bool isMsgRocketFlowerExtension(const al::SensorMsg*);
bool isMsgSandSharkAttack(const al::SensorMsg*);
bool isMsgSeedAttack(const al::SensorMsg*);
bool isMsgSeedAttackBig(const al::SensorMsg*);
bool isMsgSeedAttackHold(const al::SensorMsg*);
bool isMsgSeedItemGet(const al::SensorMsg*);
bool isMsgSeedReflect(const al::SensorMsg*);
bool isMsgSeedTouch(const al::SensorMsg*);
bool isMsgSenobiCancelStretch(const al::SensorMsg*);
bool isMsgSenobiPunchBlockTransparent(const al::SensorMsg*);
bool isMsgSenobiPartsMove(const al::SensorMsg*);
bool isMsgSenobiTrample(const al::SensorMsg*);
bool isMsgShibakenApproach(const al::SensorMsg*);
bool isMsgShibakenKick(const al::SensorMsg*);
bool isMsgSkaterAttack(const al::SensorMsg*);
bool isMsgSpherePush(const al::SensorMsg*);
bool isMsgSphinxJumpAttack(const al::SensorMsg*);
bool isMsgSphinxQuizRouteKill(const al::SensorMsg*);
bool isMsgSphinxRideAttack(const al::SensorMsg*);
bool isMsgSphinxRideAttackReflect(const al::SensorMsg*);
bool isMsgSphinxRideAttackTouchThrough(const al::SensorMsg*);
bool isMsgSphinxRideAttackTouch(const al::SensorMsg*);
bool isMsgStampTo2D(const al::SensorMsg*);
bool isMsgStartHack(const al::SensorMsg*);
bool isMsgStartInSaucePan(const al::SensorMsg*);
bool isMsgStatueDrop(const al::SensorMsg*);
bool isMsgStatueTrampleReflect(const al::SensorMsg*);
bool isMsgStatuePush(const al::SensorMsg*);
bool isMsgStatueSnap(const al::SensorMsg*);
bool isMsgSunshineAttack(const al::SensorMsg*);
bool isMsgTankBullet(const al::SensorMsg*);
bool isMsgTankBulletNoReaction(const al::SensorMsg*);
bool isMsgTankExplosion(const al::SensorMsg*);
bool isMsgTankHackTrample(const al::SensorMsg*);
bool isMsgTankKickHack(const al::SensorMsg*);
bool isMsgTankKickEnemy(const al::SensorMsg*);
bool isMsgTankLookOn(const al::SensorMsg*);
bool isMsgTestPunch(const al::SensorMsg*);
bool isMsgTestPunchStrong(const al::SensorMsg*);
bool isMsgTimerAthleticDemoStart(const al::SensorMsg*);
bool isMsgTouchDoorDrumn(const al::SensorMsg*);
bool isMsgTouchFireDrum2D(const al::SensorMsg*);
bool isMsgTrashBoxIn(const al::SensorMsg*);
bool isMsgTRexAttack(const al::SensorMsg*);
bool isMsgTRexAttackCollideAll(const al::SensorMsg*);
bool isMsgTRexAttackCollideBody(const al::SensorMsg*);
bool isMsgTRexAttackCollideHead(const al::SensorMsg*);
bool isMsgTRexDashAttack(const al::SensorMsg*);
bool isMsgTRexScrollPartsBreakWith(const al::SensorMsg*);
bool isMsgTsukkunForceCancelCollide(const al::SensorMsg*);
bool isMsgTsukkunHoldCollide(const al::SensorMsg*);
bool isMsgTsukkunThroughCollide(const al::SensorMsg*);
bool isMsgTsukkunThrustAll(const al::SensorMsg*);
bool isMsgTsukkunThrust(const al::SensorMsg*, bool*);
bool isMsgTsukkunThrustCollide(const al::SensorMsg*, bool*);
bool isMsgTsukkunNoTrace(const al::SensorMsg*);
bool isMsgTsukkunThrustHole(const al::SensorMsg*);
bool isMsgUtsuboAttack(const al::SensorMsg*);
bool isMsgWanderBossCameraRange(const al::SensorMsg*);
bool isMsgWanwanEnemyAttack(const al::SensorMsg*);
bool isMsgWanwanBlockAttack(const al::SensorMsg*);
bool isMsgWanwanHoleIn(const al::SensorMsg*);
bool isMsgWaterRoadIn(const al::SensorMsg*);
bool isMsgWaterRoadNear(const al::SensorMsg*);
bool isMsgWanwanPush(const al::SensorMsg*);
bool isMsgWanwanReboundAttack(const al::SensorMsg*);
bool isMsgWeaponItemGet(const al::SensorMsg*);
bool isMsgWhipAttack(const al::SensorMsg*);
bool isMsgWhipBind(const al::SensorMsg*);
bool isMsgWhipHold(const al::SensorMsg*);
bool isMsgWhipThrow(const al::SensorMsg*);
bool isMsgYokinBallAttack(const al::SensorMsg*);
bool isMsgYoshiDirectEat(const al::SensorMsg*);
bool isMsgYoshiTongueAttack(const al::SensorMsg*);
bool isMsgYoshiTongueEatBind(const al::SensorMsg*);
bool isMsgYoshiTongueEatBindCancel(const al::SensorMsg*);
bool isMsgYoshiTongueEatBindFinish(const al::SensorMsg*);
bool isMsgYoshiTongueEatHomingTarget(const al::SensorMsg*);
bool isMsgYukimaruPush(const al::SensorMsg*);
bool isMsgKillerAttackNoExplode(const al::SensorMsg*);
bool isMsgKillerMagnumAttack(const al::SensorMsg*);
bool isMsgKillerMagnumHackAttack(const al::SensorMsg*);
bool isMsgGabuzouAttack(const al::SensorMsg*);
bool isMsgStackerRollingAttack(const al::SensorMsg*);
bool isMsgStackerCapBoostAttack(const al::SensorMsg*);
bool isMsgIgnoreIgnitionBomb(const al::SensorMsg*);
bool isMsgExplosionReflectBomb(const al::SensorMsg*);
bool isMsgGolemStampPress(const al::SensorMsg*);
void setMsgYoshiTongueEatBindRadiusAndOffset(const al::SensorMsg*, f32, f32);
void setMsgYoshiTongueEatBindScale(const al::SensorMsg*, f32);
bool isMsgTsukkunThrustSpin(const al::SensorMsg*, bool*);
bool isMsgTsukkunThrustReflect(const al::SensorMsg*, bool*);
bool isMsgTsukkunThrustHitReflectCollide(const al::SensorMsg*, bool*);
bool isMsgTsukkunThrustReflectCollide(const al::SensorMsg*, bool*);
bool isMsgSwitchOnWithSaveRequest(const al::SensorMsg*, SaveObjInfo**);
bool isMsgNpcCapReactionAll(const al::SensorMsg*);
bool isMsgHackNpcCapReactionAll(const al::SensorMsg*);
bool checkMsgNpcTrampleReactionAll(const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*,
                                   bool);
bool isMsgPlayerAndCapObjHipDropReflectAll(const al::SensorMsg*);
bool isMsgKoopaCapPunchAll(const al::SensorMsg*);
bool isMsgKoopaCapPunchInvincibleAll(const al::SensorMsg*);
bool isMsgKoopaCapPunchFinishAll(const al::SensorMsg*);
bool isMsgItemGet(const al::SensorMsg*);
bool isMsgItemGetByWeapon(const al::SensorMsg*);
bool isMsgItemGet2D(const al::SensorMsg*);
bool isMsgBlockUpperPunch2D(const al::SensorMsg*);
bool isMsgItemGetAll(const al::SensorMsg*);
bool isMsgShineGet(const al::SensorMsg*);
bool isMsgShineGet2D(const al::SensorMsg*);
bool isMsgShineReaction(const al::SensorMsg*);
bool isMsgKillByShineGet(const al::SensorMsg*);
bool isMsgKillByHomeDemo(const al::SensorMsg*);
bool isMsgEndHomeDemo(const al::SensorMsg*);
bool isMsgBreakBySword(const al::SensorMsg*);
bool isMsgPressDown(const al::SensorMsg*);
bool isMsgPlayerAndCapObjHipDropAll(const al::SensorMsg*);
bool isMsgAttackDirect(const al::SensorMsg*);
bool isMsgBlowDown(const al::SensorMsg*);
bool isMsgTrampleReflectAll(const al::SensorMsg*);
bool isMsgThrowObjHit(const al::SensorMsg*);
bool isMsgThrowObjHitReflect(const al::SensorMsg*);
bool isMsgPlayerAndCapHipDropAll(const al::SensorMsg*);
bool isMsgUpperPunchAll(const al::SensorMsg*);
bool sendMsgBlockUpperPunch2D(al::HitSensor* source, al::HitSensor* target);
bool isMsgBlockReaction2D(const al::SensorMsg*);
bool isMsgBlockReaction3D(const al::SensorMsg*);
bool isMsgBlockReactionAll(const al::SensorMsg*);
bool isMsgBreakFrailBox(const al::SensorMsg*);
bool isMsgDamageFrailBox(const al::SensorMsg*);
bool isMsgChorobonReaction(const al::SensorMsg*);
bool isMsgBreakSignBoard(const al::SensorMsg*);
bool isMsgBreakCollapseSandHill(const al::SensorMsg*);
void calcBlowDownDir(sead::Vector3f*, const al::SensorMsg*, al::HitSensor* source,
                     al::HitSensor* target);
bool tryGetTsukkunThrustDir(sead::Vector3f*, const al::SensorMsg*);
bool isMsgPlayerDamage(const al::SensorMsg*);
bool isMsgPlayerDamage2D(const al::SensorMsg*);
bool isMsgPlayerDamageBlowDown(const al::SensorMsg*);
bool isMsgPlayerJumpRequestAll(const al::SensorMsg*);
bool trySendMsgHackPunchToCeil(al::LiveActor*, al::HitSensor*);
bool trySendMsgHackPunchToSensor(al::LiveActor*, al::HitSensor* source, al::HitSensor* target);
bool isMsgDashPanel(const al::SensorMsg*, s32*);
bool isMsgNetworkShootingShot(const al::SensorMsg*, s32);
bool isMsgNetworkShootingChargeShot(const al::SensorMsg*, s32);
bool isMsgRaceReturnToCourse(const al::SensorMsg*, sead::Vector3f*, sead::Vector3f*);
bool isFallingTargetMoonBasementRock(const al::SensorMsg*);
bool tryGetTestPunchInfo(sead::Vector3f*, s32*, const al::SensorMsg*, s32);
bool tryGetTestPunchTeamId(s32*, const al::SensorMsg*);
bool tryGetPunchGuard(s32*, const al::SensorMsg*, s32);
bool tryGetTsukkunThrustInfo(sead::Vector3f*, s32*, const al::SensorMsg*);
bool tryGetTsukkunThrustReflectDir(sead::Vector3f*, const al::SensorMsg*);
bool tryGetTsukkunThrustHole(sead::Vector3f*, sead::Vector3f*, const al::SensorMsg*);
bool tryGetRequestPlayerJumpInfo(f32*, const al::SensorMsg*);
bool tryGetRequestPlayerTrampleJumpInfo(f32*, const al::SensorMsg*);
bool tryGetRequestPlayerSpinJumpInfo(f32*, const al::SensorMsg*);
bool tryGetRequestSphinxJumpInfo(f32*, const al::SensorMsg*);
bool tryGetTouchTargetInfo(TouchTargetInfo**, const al::SensorMsg*);
bool tryGetTouchTargetInfoCollisionTouchPos(sead::Vector3f*, const al::SensorMsg*);
bool tryInitTouchTargetInfoBySensorOffset(const al::SensorMsg*, const al::HitSensor*,
                                          const sead::Vector3f&, const sead::Vector3f&);
bool tryInitTouchTargetInfoByConnector(const al::SensorMsg*, const al::MtxConnector*,
                                       const sead::Vector3f&, const sead::Vector3f&, bool);
bool tryCalcCollisionImpulse(sead::Vector3f*, f32, const sead::Vector3f&, f32,
                             const al::SensorMsg*);
bool tryInitWhipTarget(const al::SensorMsg*, al::HitSensor*, const sead::Vector3f*);
bool tryGetWhipThrowDir(sead::Vector3f*, const al::SensorMsg*);
bool tryMagnetPower(bool*, const al::SensorMsg*);
bool tryMagnetBulletAttack(f32*, const al::SensorMsg*);
bool isMsgTrampolineCrackJump(f32*, f32*, const al::SensorMsg*);
void requestHitReactionToAttacker(const al::SensorMsg*, const al::HitSensor*, const al::HitSensor*);
void requestHitReactionToAttacker(const al::SensorMsg*, const al::HitSensor*,
                                  const sead::Vector3f&);
bool tryGetCapTouchWallHitPos(sead::Vector3f*, const al::SensorMsg*);
bool tryGetCapTouchWallNormal(sead::Vector3f*, const al::SensorMsg*);
bool isCapRethrowReturnOnly(const al::SensorMsg*);
bool tryGetCapRethrowPos(sead::Vector3f*, const al::SensorMsg*);
bool tryGetCapRethrowFront(sead::Vector3f*, const al::SensorMsg*);
bool tryGetCapRethrowUp(sead::Vector3f*, const al::SensorMsg*);
bool tryGetHackBlowJump(sead::Vector3f*, f32*, const al::SensorMsg*);
bool tryGetGolemStampPushV(f32*, const al::SensorMsg*);
bool tryGetGolemStampPushH(f32*, const al::SensorMsg*);
bool tryGetRequestPlayerWaitAnim(const char**, const al::SensorMsg*);
bool tryGetCapChangeGiant(f32*, s32*, const al::SensorMsg*);
bool tryGetByugoBlowForce(sead::Vector3f*, const al::SensorMsg*);
bool tryGetObjSnapForce(sead::Vector3f*, const al::SensorMsg*);
void getPackunEatCancelPosAndFront(sead::Vector3f*, sead::Vector3f*, const al::SensorMsg*);
bool tryGetPackunEatEndPos(sead::Vector3f*, const al::SensorMsg*);
bool tryGetPackunEatEndDir(sead::Vector3f*, const al::SensorMsg*);
bool tryGetPackunEatStartFollowPos(const sead::Vector3f**, const al::SensorMsg*);
bool tryGetFireBlowerAttackPos(sead::Vector3f*, const al::SensorMsg*);
bool tryGetFireBlowerAttackDir(sead::Vector3f*, const al::SensorMsg*);
bool tryGetFireBlowerAttackRadius(f32*, const al::SensorMsg*);
bool tryGetPaintColor(sead::Color4u8*, const al::SensorMsg*);
bool tryGetPaintSize(f32*, const al::SensorMsg*);
bool tryGetPaintDrawType(s32*, const al::SensorMsg*);
bool tryGetPaintTextureSize(f32*, const al::SensorMsg*);
bool tryGetPaintTextureRotation(f32*, const al::SensorMsg*);
bool tryGetPaintTextureDrawType(s32*, const al::SensorMsg*);
bool tryGetCheckPaintClearColor(sead::Color4u8*, const al::SensorMsg*);
bool tryGetCheckPaintClearPos(sead::Vector3f*, const al::SensorMsg*);
bool tryGetCheckPaintClearDrawType(s32*, const al::SensorMsg*);
bool tryGetCheckPaintAlphaPos(sead::Vector3f*, const al::SensorMsg*);
bool tryGetSenobiPartsMoveDistance(f32*, const al::SensorMsg*);
bool tryGetSenobiPartsCollidedNormal(sead::Vector3f*, const al::SensorMsg*);
bool tryGetStampTo2DForce(sead::Vector3f*, const al::SensorMsg*);
bool tryGetGhostStartOkObjId(sead::BufferedSafeStringBase<char>*, const al::SensorMsg*);
bool tryGetAirExplosionForce(sead::Vector3f*, const al::SensorMsg*);
bool sendMsgGotogotonOn(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGotogotonGetJumpPath(al::HitSensor* source, al::HitSensor* target, al::ParabolicPath*);
bool sendMsgGotogotonGoalExist(al::HitSensor* source, al::HitSensor* target);
bool sendMsgGotogotonGoalMatch(al::HitSensor* source, al::HitSensor* target, const GotogotonMark*);
bool isMatchGotogotonGoal(const al::SensorMsg*, const GotogotonMark*);
bool isMsgGotogotonOn(const al::SensorMsg*);
bool isMsgGotogotonGoalExist(const al::SensorMsg*);
bool sendMsgBossMagmaBreathForce(al::HitSensor* source, al::HitSensor* target,
                                 const sead::Vector3f&);
bool sendMsgBossMagmaCatchPlayer(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossMagmaReleasePlayer(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossMagmaDeadDemoStart(al::HitSensor* source, al::HitSensor* target);
bool sendMsgBossMagmaDeadDemoEnd(al::HitSensor* source, al::HitSensor* target,
                                 const sead::Vector3f&);
bool sendMsgBossMagmaResetPos(al::HitSensor* source, al::HitSensor* target, const sead::Vector3f&);
bool sendMsgBossMagmaQueryToBubble(al::HitSensor* source, al::HitSensor* target);
bool isMsgBossMagmaCatchPlayer(const al::SensorMsg*);
bool isMsgBossMagmaReleasePlayer(const al::SensorMsg*);
bool isMsgBossMagmaDeadDemoStart(const al::SensorMsg*);
bool isMsgBossMagmaDeadDemoEnd(const al::SensorMsg*);
bool tryGetBossMagmaDeadDemoEndTargetPos(const al::SensorMsg*, sead::Vector3f*);
bool tryGetBossMagmaBreathForce(const al::SensorMsg*, sead::Vector3f*);
bool tryGetBossMagmaResetPos(const al::SensorMsg*, sead::Vector3f*);
bool isMsgBossMagmaQueryToBubble(const al::SensorMsg*);
s32 getMofumofuBodyChainExplodeDelayStep(const al::SensorMsg*);
bool isMsgMofumofuReflectAll(const al::SensorMsg*);
void calcFishingUpJugemDir(sead::Vector3f*, const al::SensorMsg*);
const sead::Vector3f& getFishingUpFloatPos(const al::SensorMsg*);
const char* tryGetFishingUpFloatMaterialCode(const al::SensorMsg*);
al::HitSensor* getFishingHookSensor(const al::SensorMsg*);
bool sendMsgCheckFishingTarget(al::HitSensor* source, al::HitSensor* target, const FishingFish*);
bool isMsgCheckFishingTarget(const al::SensorMsg*);
const FishingFish* getCheckFishingTarget(const al::SensorMsg*);
const sead::Vector3f& getGunetterPushCenter(const al::SensorMsg*);
f32 getGunetterPushRadius(const al::SensorMsg*);
u32 getNumKuriboTowerOn(const al::SensorMsg*);
bool isMsgPlayerLookAtPosition(const al::SensorMsg*);
void setMsgPlayerLookAtPosition(const al::SensorMsg*, const sead::Vector3f&);
bool isMsgTargetMarkerPosition(const al::SensorMsg*);
void setMsgTargetMarkerPosition(const al::SensorMsg*, const sead::Vector3f&);
bool isMsgSandGeyserRaise(const al::SensorMsg*);
bool tryGetSandGeyserRaise(const al::SensorMsg*, f32*, f32*);
void tryTreasureBoxPlayerTrampleJump(al::LiveActor*, al::HitSensor* source, al::HitSensor* target,
                                     f32);
bool sendMsgPushToPlayerAndKillVelocityToTarget(al::LiveActor*, al::HitSensor* source,
                                                al::HitSensor* target);
bool sendMsgPushToPlayerAndKillVelocityToTargetH(al::LiveActor*, al::HitSensor* source,
                                                 al::HitSensor* target);
bool tryReceivePushAndAddVelocity(al::LiveActor*, const al::SensorMsg*);
bool tryReceiveMsgPushToPlayerAndAddVelocity(al::LiveActor*, const al::SensorMsg*,
                                             const al::HitSensor*, const al::HitSensor*, f32);
bool tryReceiveMsgPushToPlayerAndAddVelocityH(al::LiveActor*, const al::SensorMsg*,
                                              const al::HitSensor*, const al::HitSensor*, f32);
bool tryReceiveMsgPushToPlayerAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*,
                                               const al::LiveActor*, const al::HitSensor*,
                                               const al::HitSensor*, f32);
bool tryReceiveMsgPushToHackerAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*,
                                               const al::LiveActor*, const al::HitSensor*,
                                               const al::HitSensor*, f32, bool);
bool tryReceiveMsgPushToYoshiNpcAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*,
                                                 const al::LiveActor*, const al::HitSensor*,
                                                 const al::HitSensor*, f32);
bool tryReceiveMsgPushToCapAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*,
                                            const al::LiveActor*, const al::HitSensor*,
                                            const al::HitSensor*, f32);
bool tryReceiveMsgPushToGrowPlantAndCalcPushTrans(sead::Vector3f*, const al::SensorMsg*,
                                                  const al::LiveActor*, const al::HitSensor*,
                                                  const al::HitSensor*, f32);
bool sendMsgInitCapTarget(al::HitSensor* source, al::HitSensor* target, const CapTargetInfo**);
bool isMsgInitCapTarget(const al::SensorMsg*);
void setCapTargetInfo(const al::SensorMsg*, const CapTargetInfo*);
bool tryReceiveMsgInitCapTargetAndSetCapTargetInfo(const al::SensorMsg*, const CapTargetInfo*);
bool sendMsgTransferHack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgRequestTransferHack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgInitHack(al::HitSensor* source, al::HitSensor* target);
bool sendMsgEndHack(al::HitSensor* source, al::HitSensor* target, const HackEndParam*);
bool isMsgTransferHack(const al::SensorMsg*);
bool isMsgRequestTransferHack(const al::SensorMsg*);
bool isMsgInitHack(const al::SensorMsg*);
bool isMsgEndHack(const HackEndParam**, const al::SensorMsg*);
bool isMsgHackDirectStageInit(IUsePlayerHack**, const al::SensorMsg*);
bool isMsgKillByBossBattleDemo(const al::SensorMsg*);
bool isMsgKillByHackFirstDemo(const al::SensorMsg*);
bool isMsgKillByMoonRockDemo(const al::SensorMsg*);
bool sendMsgNpcScareByEnemy(al::HitSensor* source, al::HitSensor* target, s32);
bool tryReceiveMsgNpcScareByEnemyIgnoreTargetHack(const al::SensorMsg*, const CapTargetInfo*);
bool tryIncrementComboCount(s32*, const al::SensorMsg*);
ComboCounter* tryGetMsgComboCount(const al::SensorMsg*);
ComboCounter* getMsgComboCount(const al::SensorMsg*);
bool isRideOn(const al::HitSensor*, const al::HitSensor*);
bool isMsgKillBySwitchTimer(const al::SensorMsg*);
bool isVisibleChameleon(const al::SensorMsg*);
bool isMsgRequestPlayerStainWet(const al::SensorMsg*, s32*);
s32 tryGetKuriboTowerNum(al::HitSensor* source, al::HitSensor* target);
void setKuriboTowerNum(const al::SensorMsg*, s32);
const sead::Vector3f& getSpherePushCenter(const al::SensorMsg*);
f32 getSpherePushRadius(const al::SensorMsg*);
DigPoint* getSmellDigPoint(const al::SensorMsg*);

}  // namespace rs
