S~4

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_93622f71b2d1b3da07fa44fe633e4d31>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_93622f71b2d1b3da07fa44fe633e4d31>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_a4dc38abafd6bb1f7f898eecf86647d8>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_a4dc38abafd6bb1f7f898eecf86647d8>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_599c3e3b52bab211657dd2b12258525f>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_599c3e3b52bab211657dd2b12258525f>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_843fbf8f658197deabd5d66aca0b5d2c>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_843fbf8f658197deabd5d66aca0b5d2c>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_44713807c694a34247116ac42237d921>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_44713807c694a34247116ac42237d921>
{
  RedstoneScreenType <args_0>;
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_2dc9e558cd4384c30952098dabdf69a6>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_2dc9e558cd4384c30952098dabdf69a6>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_bf6bd47537effc5005cc8af06f921a6b>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_bf6bd47537effc5005cc8af06f921a6b>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_0ebaf0371ff09f45dab2f48e7253d4f7>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_0ebaf0371ff09f45dab2f48e7253d4f7>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_b7f24edb716c239e18ac72d4f3c6733d>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_b7f24edb716c239e18ac72d4f3c6733d>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_a36afaf8a1afa0684c71071850b6dc59>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_a36afaf8a1afa0684c71071850b6dc59>
{
  const HashedString <args_0>;
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_3d8d548af9390a3e89d693eb21f9053e>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_3d8d548af9390a3e89d693eb21f9053e>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_0b5b22390697ce2a7c10dc25a536ea1d>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_0b5b22390697ce2a7c10dc25a536ea1d>
{
};

SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_ce0fde19203617737ec3f13040734e6d>

struct __cppobj SceneCreationUtils::bindInGameScreenCreator::__l2::<lambda_ce0fde19203617737ec3f13040734e6d>
{
};

Social::<lambda_a70a5a9432f0adfeb3ed076c01d0ac59>

struct __cppobj Social::<lambda_a70a5a9432f0adfeb3ed076c01d0ac59>
{
};

Social::<lambda_52ce7f45f90c5c2a0dd6d8adeb080876>

struct __cppobj Social::<lambda_52ce7f45f90c5c2a0dd6d8adeb080876>
{
};

Social::<lambda_b7ca127a156cd86fc46069d07be131eb>

struct __cppobj Social::<lambda_b7ca127a156cd86fc46069d07be131eb>
{
};

Social::<lambda_2ffb157acc314cd7a898b1a1b9dafa1a>

struct __cppobj Social::<lambda_2ffb157acc314cd7a898b1a1b9dafa1a>
{
};

ScaffoldingClimberSystem

struct __cppobj ScaffoldingClimberSystem : ITickingSystem
{
};

ScaffoldingClimberSystem_vtbl

struct /*VFT*/ ScaffoldingClimberSystem_vtbl
{
  void (__fastcall *~ITickingSystem)(ITickingSystem *this);
  void (__fastcall *tick)(ITickingSystem *this, EntityRegistry *);
};

ScaleByAgeSystem

struct __cppobj ScaleByAgeSystem : ITickingSystem
{
};

ScaleByAgeSystem_vtbl

struct /*VFT*/ ScaleByAgeSystem_vtbl
{
  void (__fastcall *~ITickingSystem)(ITickingSystem *this);
  void (__fastcall *tick)(ITickingSystem *this, EntityRegistry *);
};

SleepState

struct __cppobj SleepState : PetSleepWithOwnerState
{
};

SleepState_vtbl

struct /*VFT*/ SleepState_vtbl
{
  void (__fastcall *~PetSleepWithOwnerState)(PetSleepWithOwnerState *this);
  void (__fastcall *tick)(PetSleepWithOwnerState *this);
  void (__fastcall *start)(PetSleepWithOwnerState *this);
  void (__fastcall *stop)(PetSleepWithOwnerState *this);
};

ScaredGoal

struct __cppobj __declspec(align(8)) ScaredGoal : Goal
{
  Mob *mMob;
  int mInterval;
};

ScaredGoal_vtbl

struct /*VFT*/ ScaredGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

ShareItemsGoal

struct __cppobj ShareItemsGoal : Goal
{
  Mob *mMob;
  int mThrowCountdown;
  int mSearchRange;
  float mSpeedModifier;
  float mGoalRadiusSq;
  int mTimeToRecalcPath;
  std::vector<MobDescriptor> mMobFilters;
  ItemStack mItemToShare;
  std::unique_ptr<Path> mPath;
};

ShareItemsGoal_vtbl

struct /*VFT*/ ShareItemsGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

ShulkerPeekGoal

struct __cppobj ShulkerPeekGoal : Goal
{
  int mPeekTime;
  Mob *mMob;
};

ShulkerPeekGoal_vtbl

struct /*VFT*/ ShulkerPeekGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SitGoal

struct __cppobj SitGoal : Goal
{
  Mob *mMob;
};

SitGoal_vtbl

struct /*VFT*/ SitGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SkeletonHorseTrapGoal

struct __cppobj SkeletonHorseTrapGoal : Goal
{
  Horse *mHorse;
  int mTrapLifeTicks;
  float mTriggerDistance;
};

SkeletonHorseTrapGoal_vtbl

struct /*VFT*/ SkeletonHorseTrapGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SleepGoal

struct __cppobj __declspec(align(8)) SleepGoal : MoveToPOIGoal
{
  Mob *mMob;
  BedHelper mBedHelper;
  BlockPos mBedPos;
  Vec3 mSleepPos;
  Vec3 mBedOffset;
  Vec3 mExitPos;
  int mBedDir;
  float mBodyRot;
  const float mSleepYOffset;
  const float mSleepColliderHeight;
  const float mSleepColliderWidth;
  Vec2 mDefaultColliderDim;
  const Tick mGoalCooldownMax;
  Tick mCooldownTick;
  bool mWoken;
  bool mGoalEndedEarly;
};

SleepGoal_vtbl

struct /*VFT*/ SleepGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
  bool (__fastcall *hasReachedTarget)(BaseMoveToGoal *this);
  bool (__fastcall *isValidTarget)(BaseMoveToGoal *this, BlockSource *, const BlockPos *);
  int (__fastcall *_nextStartTick)(BaseMoveToGoal *this);
  bool (__fastcall *_canReach)(BaseMoveToGoal *this, const BlockPos *);
  void (__fastcall *_moveToBlock)(BaseMoveToGoal *this);
  Vec3 *(__fastcall *_getTargetPosition)(BaseMoveToGoal *this, Vec3 *result);
  unsigned __int64 (__fastcall *_getRepathTime)(BaseMoveToGoal *this);
  bool (__fastcall *getPOI)(MoveToPOIGoal *this, POIType);
  std::weak_ptr<POIInstance> *(__fastcall *_getOwnedPOI)(MoveToPOIGoal *this, std::weak_ptr<POIInstance> *result, POIType);
};

SlimeAttackDefinition

struct __cppobj __declspec(align(8)) SlimeAttackDefinition : BaseGoalDefinition
{
  float mMaxRotationX;
  float mMaxRotationY;
  float mSpeedMultiplier;
  float mGrowTiredCooldownTime;
  bool mSetPersistent;
};

SlimeAttackDefinition_vtbl

struct /*VFT*/ SlimeAttackDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

SlimeAttackGoal

struct __cppobj SlimeAttackGoal : Goal
{
  Mob *mMob;
  int mGrowTiredTicks;
  int mGrowTiredCooldownTicks;
  float mMaxRotationX;
  float mMaxRotationY;
  float mSpeedMultiplier;
  float mSetPersistent;
};

SlimeAttackGoal_vtbl

struct /*VFT*/ SlimeAttackGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SlimeFloatDefinition

struct __cppobj SlimeFloatDefinition : BaseGoalDefinition
{
  float mJumpChancePercentage;
  float mSpeedMultiplier;
};

SlimeFloatDefinition_vtbl

struct /*VFT*/ SlimeFloatDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

SlimeFloatGoal

struct __cppobj SlimeFloatGoal : Goal
{
  Mob *mMob;
  float mJumpChancePercentage;
  float mSpeedMultiplier;
};

SlimeFloatGoal_vtbl

struct /*VFT*/ SlimeFloatGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SlimeKeepOnJumpingDefinition

struct __cppobj __declspec(align(8)) SlimeKeepOnJumpingDefinition : BaseGoalDefinition
{
  float mSpeedMultiplier;
};

SlimeKeepOnJumpingDefinition_vtbl

struct /*VFT*/ SlimeKeepOnJumpingDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

SlimeKeepOnJumpingGoal

struct __cppobj __declspec(align(8)) SlimeKeepOnJumpingGoal : Goal
{
  Mob *mMob;
  float mSpeedMultiplier;
};

SlimeKeepOnJumpingGoal_vtbl

struct /*VFT*/ SlimeKeepOnJumpingGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SlimeRandomDirectionDefinition

struct __cppobj __declspec(align(8)) SlimeRandomDirectionDefinition : BaseGoalDefinition
{
  int mAddRandomTime;
  int mTurnRange;
  float mMinChangeDirectionTime;
};

SlimeRandomDirectionDefinition_vtbl

struct /*VFT*/ SlimeRandomDirectionDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

SlimeRandomDirectionGoal

struct __cppobj __declspec(align(8)) SlimeRandomDirectionGoal : Goal
{
  Mob *mMob;
  int mNextRandomizeTicks;
  int mMinChangeDirectionTicks;
  int mAddRandomTicks;
  int mTurnRange;
  float mChosenDegrees;
};

SlimeRandomDirectionGoal_vtbl

struct /*VFT*/ SlimeRandomDirectionGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SnackGoal

struct __cppobj SnackGoal : Goal
{
  Mob *mMob;
  std::vector<ItemDescriptor> mItems;
  unsigned __int64 mCooldown;
  const int mSnackCooldownTotal;
  const int mCooldownMin;
  const int mStopChance;
  TempEPtr<Actor> mTarget;
  std::unique_ptr<Path> mPath;
};

SnackGoal_vtbl

struct /*VFT*/ SnackGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
  int (__fastcall *getRandomEatingEnd)(SnackGoal *this);
};

SneezeGoal

struct __cppobj SneezeGoal : Goal
{
  int mCooldown;
  int mCooldownTimer;
  float mProbability;
  int mPreSneezeTimer;
  float mDropItemChance;
  std::string mLootTable;
  LevelSoundEvent mSneezeSound;
  LevelSoundEvent mPreSneezeSound;
  float mPrepareTime;
  const std::vector<MobDescriptor> mReactMobFilters;
  float mReactWithin;
  Mob *mMob;
};

SneezeGoal_vtbl

struct /*VFT*/ SneezeGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

StalkAndPounceOnTargetGoal

struct __cppobj __declspec(align(8)) StalkAndPounceOnTargetGoal : Goal
{
  float mStalkSpeed;
  float mStalkingMaxDistanceSqr;
  float mLeapHeight;
  float mLeapDistance;
  float mMaxPounceDistanceSqr;
  float mStrikeDistanceSqr;
  int mInterestedTicks;
  int mStuckTicks;
  Tick mEndTimestamp;
  ActorFilterGroup mStuckBlockList;
  _BYTE mState[1];
  Mob *mMob;
  bool mSetPersistent;
};

StalkAndPounceOnTargetGoal_vtbl

struct /*VFT*/ StalkAndPounceOnTargetGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

StompAttackDefinition

struct __cppobj StompAttackDefinition : MeleeAttackDefinition
{
  float mStompRangeMultiplier;
  float mNoDamageRangeMultiplier;
};

StompAttackDefinition_vtbl

struct /*VFT*/ StompAttackDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

StompAttackGoal

struct __cppobj StompAttackGoal : MeleeAttackGoal
{
  float mStompRangeMultiplier;
  float mNoDamageRangeMultiplier;
};

StompAttackGoal_vtbl

struct /*VFT*/ StompAttackGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
  void (__fastcall *_attemptMoveToTarget)(MeleeAttackGoal *this, Actor *);
  void (__fastcall *_attemptAttackTarget)(MeleeAttackGoal *this, Actor *, float, float, float);
};

StompBlockGoal

struct __cppobj __declspec(align(8)) StompBlockGoal : BaseMoveToBlockGoal
{
  const Block *mBlockToRemove;
  int mTicksSinceReachedGoal;
};

StompBlockGoal_vtbl

struct /*VFT*/ StompBlockGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
  bool (__fastcall *hasReachedTarget)(BaseMoveToGoal *this);
  bool (__fastcall *isValidTarget)(BaseMoveToGoal *this, BlockSource *, const BlockPos *);
  int (__fastcall *_nextStartTick)(BaseMoveToGoal *this);
  bool (__fastcall *_canReach)(BaseMoveToGoal *this, const BlockPos *);
  void (__fastcall *_moveToBlock)(BaseMoveToGoal *this);
  Vec3 *(__fastcall *_getTargetPosition)(BaseMoveToGoal *this, Vec3 *result);
  unsigned __int64 (__fastcall *_getRepathTime)(BaseMoveToGoal *this);
  bool (__fastcall *findTargetBlock)(BaseMoveToBlockGoal *this);
  void (__fastcall *_createBreakProgressParticles)(StompBlockGoal *this, Level *, BlockSource *, BlockPos);
  void (__fastcall *_createDestroyParticles)(StompBlockGoal *this, Level *, BlockSource *, BlockPos);
  void (__fastcall *_playBreakProgressSound)(StompBlockGoal *this, Level *, BlockSource *, BlockPos);
  void (__fastcall *_playDestroySound)(StompBlockGoal *this, Level *, BlockSource *, BlockPos);
};

StompBlockGoal::findTargetBlock::__l2::<lambda_a693b3bf6a29e3a3addea54b11f109b6>

struct __cppobj StompBlockGoal::findTargetBlock::__l2::<lambda_a693b3bf6a29e3a3addea54b11f109b6>
{
  StompBlockGoal *const __this;
};

StompEggGoal

struct __cppobj StompEggGoal : StompBlockGoal
{
};

StompEggGoal_vtbl

struct /*VFT*/ StompEggGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
  bool (__fastcall *hasReachedTarget)(BaseMoveToGoal *this);
  bool (__fastcall *isValidTarget)(BaseMoveToGoal *this, BlockSource *, const BlockPos *);
  int (__fastcall *_nextStartTick)(BaseMoveToGoal *this);
  bool (__fastcall *_canReach)(BaseMoveToGoal *this, const BlockPos *);
  void (__fastcall *_moveToBlock)(BaseMoveToGoal *this);
  Vec3 *(__fastcall *_getTargetPosition)(BaseMoveToGoal *this, Vec3 *result);
  unsigned __int64 (__fastcall *_getRepathTime)(BaseMoveToGoal *this);
  bool (__fastcall *findTargetBlock)(BaseMoveToBlockGoal *this);
  void (__fastcall *_createBreakProgressParticles)(StompBlockGoal *this, Level *, BlockSource *, BlockPos);
  void (__fastcall *_createDestroyParticles)(StompBlockGoal *this, Level *, BlockSource *, BlockPos);
  void (__fastcall *_playBreakProgressSound)(StompBlockGoal *this, Level *, BlockSource *, BlockPos);
  void (__fastcall *_playDestroySound)(StompBlockGoal *this, Level *, BlockSource *, BlockPos);
};

StrollTowardsVillageGoal

struct __cppobj __declspec(align(8)) StrollTowardsVillageGoal : MoveToVillageGoal
{
  float mStartChance;
};

StrollTowardsVillageGoal_vtbl

struct /*VFT*/ StrollTowardsVillageGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
  bool (__fastcall *hasReachedTarget)(BaseMoveToGoal *this);
  bool (__fastcall *isValidTarget)(BaseMoveToGoal *this, BlockSource *, const BlockPos *);
  int (__fastcall *_nextStartTick)(BaseMoveToGoal *this);
  bool (__fastcall *_canReach)(BaseMoveToGoal *this, const BlockPos *);
  void (__fastcall *_moveToBlock)(BaseMoveToGoal *this);
  Vec3 *(__fastcall *_getTargetPosition)(BaseMoveToGoal *this, Vec3 *result);
  unsigned __int64 (__fastcall *_getRepathTime)(BaseMoveToGoal *this);
  BlockPos *(__fastcall *_selectRandomPosInVillage)(MoveToVillageGoal *this, BlockPos *result);
};

SwellGoal

struct __cppobj SwellGoal : Goal
{
  Creeper *mCreeper;
  float mStartSwellDist;
  float mStopSwellDist;
  TempEPtr<Actor> mTarget;
};

SwellGoal_vtbl

struct /*VFT*/ SwellGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SwimIdleDefinition

struct __cppobj SwimIdleDefinition : BaseGoalDefinition
{
  float mSuccessRate;
  float mIdleTime;
};

SwimIdleDefinition_vtbl

struct /*VFT*/ SwimIdleDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

SwimIdleGoal

struct __cppobj SwimIdleGoal : Goal
{
  Mob *mMob;
  int mTicks;
  int mIdleTicks;
  float mSuccessRate;
  Vec3 mWantedPosition;
};

SwimIdleGoal_vtbl

struct /*VFT*/ SwimIdleGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SwimWanderDefinition

struct __cppobj SwimWanderDefinition : BaseGoalDefinition
{
  float mInterval;
  float mLookAheadDistance;
  float mSpeedMultiplier;
  float mWanderTime;
};

SwimWanderDefinition_vtbl

struct /*VFT*/ SwimWanderDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

SwimWanderGoal

struct __cppobj SwimWanderGoal : Goal
{
  Mob *mMob;
  int mTicks;
  int mWanderTicks;
  float mInterval;
  float mLookAheadDistance;
  float mSpeedMultiplier;
  Vec3 mWanted;
};

SwimWanderGoal_vtbl

struct /*VFT*/ SwimWanderGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SwimWithEntityDefinition

struct __cppobj SwimWithEntityDefinition : BaseGoalDefinition
{
  float mSuccessRate;
  float mChanceToStop;
  float mIntervalRefreshTime;
  float mCatchUpThreshold;
  float mMatchDirectionThreshold;
  float mCatchUpMultiplier;
  float mSpeedMultiplier;
  float mSearchRange;
  float mStopDistance;
  std::vector<MobDescriptor> mTargetTypes;
};

SwimWithEntityDefinition_vtbl

struct /*VFT*/ SwimWithEntityDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

SwimWithEntityGoal

struct __cppobj SwimWithEntityGoal : Goal
{
  Mob *mMob;
  TempEPtr<Actor> mFollowing;
  int mIntervalRefreshTicks;
  int mIntervalTicks;
  float mChanceToStop;
  float mSuccessRate;
  float mCatchUpThreshold;
  float mMatchDirectionThreshold;
  float mCatchUpMultiplier;
  float mSpeedMultiplier;
  float mSearchRange;
  float mStopDistance;
  SwimWithEntityGoal::EntityGoals mCurrentGoal;
  std::vector<MobDescriptor> mTargetTypes;
};

SwimWithEntityGoal_vtbl

struct /*VFT*/ SwimWithEntityGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SwoopAttackDefinition

struct __cppobj SwoopAttackDefinition : BaseGoalDefinition
{
  float mDamageReach;
  float mSpeedMultiplier;
  FloatRange mCooldownTime;
};

SwoopAttackDefinition_vtbl

struct /*VFT*/ SwoopAttackDefinition_vtbl
{
  void (__fastcall *~BaseGoalDefinition)(BaseGoalDefinition *this);
  bool (__fastcall *validateMobType)(BaseGoalDefinition *this, Mob *);
  bool (__fastcall *validate)(BaseGoalDefinition *this, Mob *);
};

SwoopAttackGoal

struct __cppobj SwoopAttackGoal : Goal
{
  Mob *mMob;
  bool mHurtTarget;
  int mAttackTicks;
  float mDamageReach;
  float mSpeedMultiplier;
  FloatRange mCooldownTicks;
};

SwoopAttackGoal_vtbl

struct /*VFT*/ SwoopAttackGoal_vtbl
{
  void (__fastcall *~Goal)(Goal *this);
  bool (__fastcall *canUse)(Goal *this);
  bool (__fastcall *canContinueToUse)(Goal *this);
  bool (__fastcall *canBeInterrupted)(Goal *this);
  void (__fastcall *start)(Goal *this);
  void (__fastcall *stop)(Goal *this);
  void (__fastcall *tick)(Goal *this);
  void (__fastcall *appendDebugInfo)(Goal *this, std::string *);
  bool (__fastcall *isTargetGoal)(Goal *this);
  void (__fastcall *onPlayerDimensionChanged)(Goal *this, Player *, AutomaticID<Dimension,int>);
};

SwoopAttackDefinition::buildSchema::__l2::<lambda_0a8e5f314faa38471a21cb2cdc3a3253>

struct __cppobj SwoopAttackDefinition::buildSchema::__l2::<lambda_0a8e5f314faa38471a21cb2cdc3a3253>
{
  bool cooldownJsonRequired;
  std::string cooldownField;
};

SwoopAttackDefinition::buildSchema::__l2::<lambda_dac5f2c072a8807319193c03bd4687d5>

struct __cppobj SwoopAttackDefinition::buildSchema::__l2::<lambda_dac5f2c072a8807319193c03bd4687d5>
{
};

SmithingTableContainerManagerController::_setupCallbacks::__l8::<lambda_7fd07675839948997f4dbbeb20ca8892>

struct __cppobj SmithingTableContainerManagerController::_setupCallbacks::__l8::<lambda_7fd07675839948997f4dbbeb20ca8892>
{
  SmithingTableContainerManagerController *const __this;
};

SmithingTableContainerManagerController::_setupCallbacks::__l5::<lambda_6f8bbbdf91b02ffa39d5070bc0fe2f56>

struct __cppobj SmithingTableContainerManagerController::_setupCallbacks::__l5::<lambda_6f8bbbdf91b02ffa39d5070bc0fe2f56>
{
  SmithingTableContainerManagerController *const __this;
};

StonecutterContainerManagerController::_setupCallbacks::__l2::<lambda_14fc1e693546ebebc2676629b20a40fb>

struct __cppobj StonecutterContainerManagerController::_setupCallbacks::__l2::<lambda_14fc1e693546ebebc2676629b20a40fb>
{
  StonecutterContainerManagerController *const __this;
};

StonecutterContainerManagerModel::getResultForItem::__l2::<lambda_941bbeac7973bc74b49ff8e09c55ff70>

struct __cppobj StonecutterContainerManagerModel::getResultForItem::__l2::<lambda_941bbeac7973bc74b49ff8e09c55ff70>
{
  std::vector<std::reference_wrapper<Recipe const >> *recipes;
};

SpikeFeature::EndSpike

struct __cppobj SpikeFeature::EndSpike
{
  const int mCenterX;
  const int mCenterZ;
  const int mRadius;
  const int mHeight;
  const bool mGuarded;
  const AABB mTopBoundingBox;
};

SpikeFeature_vtbl

struct /*VFT*/ SpikeFeature_vtbl
{
  void (__fastcall *~IFeature)(IFeature *this);
  std::optional<BlockPos> *(__fastcall *place)(IFeature *this, std::optional<BlockPos> *result, IBlockWorldGenAPI *, const BlockPos *, Random *, RenderParams *);
  std::string *(__fastcall *getStructureName)(IFeature *this, std::string *result);
  bool (__fastcall *parse)(IFeature *this, const rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > *, IWorldRegistriesProvider *);
  bool (__fastcall *place)(Feature *this, BlockSource *, const BlockPos *, Random *);
};

ScatteredFeatureStart

struct __cppobj ScatteredFeatureStart : StructureStart
{
};

ScatteredFeatureStart_vtbl

struct /*VFT*/ ScatteredFeatureStart_vtbl
{
  void (__fastcall *~StructureStart)(StructureStart *this);
  bool (__fastcall *postProcess)(StructureStart *this, BlockSource *, Random *, const BoundingBox *);
  bool (__fastcall *isValid)(StructureStart *this);
  StructureFeatureType (__fastcall *getType)(StructureStart *this);
};

StrongholdFeature

struct __cppobj StrongholdFeature : StructureFeature
{
  bool isSpotSelected;
  const Biome *forceBiomeOverride;
  ChunkPos selectedChunks[3];
  VillageFeature *villages;
  std::mutex positionMutex;
  const int TOTAL_VILLAGE_STRONGHOLDS;
  const int GRID_SIZE;
  const int GRID_INSET;
  const int MIN_STRONGHOLD_DISTANCE;
  const float STRONGHOLD_CHANCE;
  const int MAX_GRID_SEARCH_DISTANCE;
};

StrongholdFeature_vtbl

struct /*VFT*/ StrongholdFeature_vtbl
{
  void (__fastcall *~StructureFeature)(StructureFeature *this);
  bool (__fastcall *postProcess)(StructureFeature *this, BlockSource *, Random *, int, int);
  bool (__fastcall *getNearestGeneratedFeature)(StructureFeature *this, Dimension *, BiomeSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *isFeatureChunk)(StructureFeature *this, const BiomeSource *, Random *, const ChunkPos *, unsigned int);
  std::unique_ptr<StructureStart> *(__fastcall *createStructureStart)(StructureFeature *this, std::unique_ptr<StructureStart> *result, Dimension *, BiomeSource *, Random *, const ChunkPos *);
  StructureStart *(__fastcall *getStructureAt)(StructureFeature *this, int, int, int);
  std::vector<BlockPos> *(__fastcall *getGuesstimatedFeaturePositions)(StructureFeature *this, std::vector<BlockPos> *result);
};

ShipwreckFeature

struct __cppobj ShipwreckFeature : StructureFeature
{
  int mSpacing;
  int mMinSeparation;
  OceanMonumentFeature *mMonument;
  std::vector<int> mAllowedBiomes;
};

ShipwreckFeature_vtbl

struct /*VFT*/ ShipwreckFeature_vtbl
{
  void (__fastcall *~StructureFeature)(StructureFeature *this);
  bool (__fastcall *postProcess)(StructureFeature *this, BlockSource *, Random *, int, int);
  bool (__fastcall *getNearestGeneratedFeature)(StructureFeature *this, Dimension *, BiomeSource *, const BlockPos *, BlockPos *);
  bool (__fastcall *isFeatureChunk)(StructureFeature *this, const BiomeSource *, Random *, const ChunkPos *, unsigned int);
  std::unique_ptr<StructureStart> *(__fastcall *createStructureStart)(StructureFeature *this, std::unique_ptr<StructureStart> *result, Dimension *, BiomeSource *, Random *, const ChunkPos *);
  StructureStart *(__fastcall *getStructureAt)(StructureFeature *this, int, int, int);
  std::vector<BlockPos> *(__fastcall *getGuesstimatedFeaturePositions)(StructureFeature *this, std::vector<BlockPos> *result);
};

ShipwreckStart

struct __cppobj ShipwreckStart : StructureStart
{
};

ShipwreckStart_vtbl

struct /*VFT*/ ShipwreckStart_vtbl
{
  void (__fastcall *~StructureStart)(StructureStart *this);
  bool (__fastcall *postProcess)(StructureStart *this, BlockSource *, Random *, const BoundingBox *);
  bool (__fastcall *isValid)(StructureStart *this);
  StructureFeatureType (__fastcall *getType)(StructureStart *this);
};

ShipwreckPiece

struct __cppobj ShipwreckPiece : StructurePiece
{
};

ShipwreckPiece_vtbl

struct /*VFT*/ ShipwreckPiece_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

StrongholdStart

struct __cppobj __declspec(align(8)) StrongholdStart : StructureStart
{
  bool valid;
};

StrongholdStart_vtbl

struct /*VFT*/ StrongholdStart_vtbl
{
  void (__fastcall *~StructureStart)(StructureStart *this);
  bool (__fastcall *postProcess)(StructureStart *this, BlockSource *, Random *, const BoundingBox *);
  bool (__fastcall *isValid)(StructureStart *this);
  StructureFeatureType (__fastcall *getType)(StructureStart *this);
};

SandFeature

struct __cppobj __declspec(align(8)) SandFeature : Feature
{
  const Block *mBlock;
  int mRadius;
};

SandFeature_vtbl

struct /*VFT*/ SandFeature_vtbl
{
  void (__fastcall *~IFeature)(IFeature *this);
  std::optional<BlockPos> *(__fastcall *place)(IFeature *this, std::optional<BlockPos> *result, IBlockWorldGenAPI *, const BlockPos *, Random *, RenderParams *);
  std::string *(__fastcall *getStructureName)(IFeature *this, std::string *result);
  bool (__fastcall *parse)(IFeature *this, const rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > *, IWorldRegistriesProvider *);
  bool (__fastcall *place)(Feature *this, BlockSource *, const BlockPos *, Random *);
};

SpringFeature

struct __cppobj SpringFeature : Feature
{
  const Block *mBlock;
};

SpringFeature_vtbl

struct /*VFT*/ SpringFeature_vtbl
{
  void (__fastcall *~IFeature)(IFeature *this);
  std::optional<BlockPos> *(__fastcall *place)(IFeature *this, std::optional<BlockPos> *result, IBlockWorldGenAPI *, const BlockPos *, Random *, RenderParams *);
  std::string *(__fastcall *getStructureName)(IFeature *this, std::string *result);
  bool (__fastcall *parse)(IFeature *this, const rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > *, IWorldRegistriesProvider *);
  bool (__fastcall *place)(Feature *this, BlockSource *, const BlockPos *, Random *);
};

SeaAnemoneFeature

struct __cppobj SeaAnemoneFeature : Feature
{
};

SeaAnemoneFeature_vtbl

struct /*VFT*/ SeaAnemoneFeature_vtbl
{
  void (__fastcall *~IFeature)(IFeature *this);
  std::optional<BlockPos> *(__fastcall *place)(IFeature *this, std::optional<BlockPos> *result, IBlockWorldGenAPI *, const BlockPos *, Random *, RenderParams *);
  std::string *(__fastcall *getStructureName)(IFeature *this, std::string *result);
  bool (__fastcall *parse)(IFeature *this, const rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > *, IWorldRegistriesProvider *);
  bool (__fastcall *place)(Feature *this, BlockSource *, const BlockPos *, Random *);
};

SeagrassFeature

struct __cppobj SeagrassFeature : Feature
{
};

SeagrassFeature_vtbl

struct /*VFT*/ SeagrassFeature_vtbl
{
  void (__fastcall *~IFeature)(IFeature *this);
  std::optional<BlockPos> *(__fastcall *place)(IFeature *this, std::optional<BlockPos> *result, IBlockWorldGenAPI *, const BlockPos *, Random *, RenderParams *);
  std::string *(__fastcall *getStructureName)(IFeature *this, std::string *result);
  bool (__fastcall *parse)(IFeature *this, const rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > *, IWorldRegistriesProvider *);
  bool (__fastcall *place)(Feature *this, BlockSource *, const BlockPos *, Random *);
};

SeaPickleFeature

struct __cppobj SeaPickleFeature : Feature
{
};

SeaPickleFeature_vtbl

struct /*VFT*/ SeaPickleFeature_vtbl
{
  void (__fastcall *~IFeature)(IFeature *this);
  std::optional<BlockPos> *(__fastcall *place)(IFeature *this, std::optional<BlockPos> *result, IBlockWorldGenAPI *, const BlockPos *, Random *, RenderParams *);
  std::string *(__fastcall *getStructureName)(IFeature *this, std::string *result);
  bool (__fastcall *parse)(IFeature *this, const rapidjson::GenericValue<rapidjson::UTF8<char>,rapidjson::MemoryPoolAllocator<rapidjson::CrtAllocator> > *, IWorldRegistriesProvider *);
  bool (__fastcall *place)(Feature *this, BlockSource *, const BlockPos *, Random *);
};

SimpleTreeTrunk::_buildSchema::__l2::<lambda_9a0cf54a7c6987b75629f9dc8e25d931>

struct __cppobj SimpleTreeTrunk::_buildSchema::__l2::<lambda_9a0cf54a7c6987b75629f9dc8e25d931>
{
};

SimpleTreeTrunk::_buildSchema::__l4::<lambda_5a49cb9530c9848feed416a429bb7578>

struct __cppobj SimpleTreeTrunk::_buildSchema::__l4::<lambda_5a49cb9530c9848feed416a429bb7578>
{
};

SimpleTreeTrunk::_buildSchema::__l2::<lambda_aa946525ce16594a79edba5c0ce3c281>

struct __cppobj SimpleTreeTrunk::_buildSchema::__l2::<lambda_aa946525ce16594a79edba5c0ce3c281>
{
};

SimpleTreeTrunk::_buildSchema::__l2::<lambda_334c50db7f7943517c1d62b1a1f6ed19>

struct __cppobj SimpleTreeTrunk::_buildSchema::__l2::<lambda_334c50db7f7943517c1d62b1a1f6ed19>
{
};

SimpleTreeTrunk::_buildSchema::__l3::<lambda_47acba9ca575e196af6184deb709b75f>

struct __cppobj SimpleTreeTrunk::_buildSchema::__l3::<lambda_47acba9ca575e196af6184deb709b75f>
{
};

SimpleTreeTrunk::_buildSchema::__l2::<lambda_2694a72f79fa4fb7ed9ec7d7aeab4a73>

struct __cppobj SimpleTreeTrunk::_buildSchema::__l2::<lambda_2694a72f79fa4fb7ed9ec7d7aeab4a73>
{
};

SimpleTreeTrunk::_buildSchema::__l2::<lambda_7204e36fc61c7f88675eae865e9c7faf>

struct __cppobj SimpleTreeTrunk::_buildSchema::__l2::<lambda_7204e36fc61c7f88675eae865e9c7faf>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_4f2736b071532fdaed6c3238c29de24e>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_4f2736b071532fdaed6c3238c29de24e>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_8fdc9b990dea9ddb2781ac8baaf6f522>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_8fdc9b990dea9ddb2781ac8baaf6f522>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_f6e5d4c154a8ae9bd1f6062d56bb7f2c>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_f6e5d4c154a8ae9bd1f6062d56bb7f2c>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_5fd9c82cf29ce0f35711c88be0cbb321>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_5fd9c82cf29ce0f35711c88be0cbb321>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_6b8601fb6dc02f88ec8688cedf2edab9>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_6b8601fb6dc02f88ec8688cedf2edab9>
{
};

SimpleTreeCanopy::_buildSchema::__l5::<lambda_8a5617fb33e81e3200dd8bc1f270cae1>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l5::<lambda_8a5617fb33e81e3200dd8bc1f270cae1>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_18810eaec2e6274e1efb268878dc3223>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_18810eaec2e6274e1efb268878dc3223>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_633d5d73bf0d4ff5fb3df6ad3999b270>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_633d5d73bf0d4ff5fb3df6ad3999b270>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_f2a04e346fc5c98f20440d9e14936534>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_f2a04e346fc5c98f20440d9e14936534>
{
};

SimpleTreeCanopy::_buildSchema::__l4::<lambda_77c8da8048774a10c2ccfe7c1faf3c6d>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l4::<lambda_77c8da8048774a10c2ccfe7c1faf3c6d>
{
};

SimpleTreeCanopy::_buildSchema::__l4::<lambda_cd0696f13ce9c1d0a0684a62f58acccf>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l4::<lambda_cd0696f13ce9c1d0a0684a62f58acccf>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_0eefe2a7ccefc732975aba87eb8f6491>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_0eefe2a7ccefc732975aba87eb8f6491>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_44126bd2db340a1b088a36a59ab8f28d>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_44126bd2db340a1b088a36a59ab8f28d>
{
};

SimpleTreeCanopy::_buildSchema::__l3::<lambda_fa648e9934b0a3209964fba61308bc56>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l3::<lambda_fa648e9934b0a3209964fba61308bc56>
{
};

SimpleTreeCanopy::_buildSchema::__l3::<lambda_9239166c63a95c8d3353ef96d31987cf>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l3::<lambda_9239166c63a95c8d3353ef96d31987cf>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_d107e4e3f3cf13351d394e09260d3385>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_d107e4e3f3cf13351d394e09260d3385>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_fca7866f235039823ff3afefd1b4d428>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_fca7866f235039823ff3afefd1b4d428>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_401c47c46ba1b3035efaf6e498058cf3>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_401c47c46ba1b3035efaf6e498058cf3>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_99ca4703c28310cf1b5d42a8a68d1b8e>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_99ca4703c28310cf1b5d42a8a68d1b8e>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_17d26e6de326e0cb30a78ea9675b8c02>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_17d26e6de326e0cb30a78ea9675b8c02>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_297f1d7cada4032c574fd76d19fb9c3f>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_297f1d7cada4032c574fd76d19fb9c3f>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_d0af4e4571eece2f793be4451608e3f8>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_d0af4e4571eece2f793be4451608e3f8>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_66f16c7c6c79bb568769181120decd24>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_66f16c7c6c79bb568769181120decd24>
{
};

SimpleTreeCanopy::_buildSchema::__l4::<lambda_1e212d0f28d8e1c31753c88b2200c09c>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l4::<lambda_1e212d0f28d8e1c31753c88b2200c09c>
{
};

SimpleTreeCanopy::_buildSchema::__l4::<lambda_413cf5e39448ade55c26a9f72b911c3f>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l4::<lambda_413cf5e39448ade55c26a9f72b911c3f>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_2b1dec13cb427f4a2c5893153eb1ccfb>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_2b1dec13cb427f4a2c5893153eb1ccfb>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_b0526add3214a40b1f63dc26b9bec28d>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_b0526add3214a40b1f63dc26b9bec28d>
{
};

SimpleTreeCanopy::_buildSchema::__l3::<lambda_9b8ce1f677434b80763cdd6dc239f214>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l3::<lambda_9b8ce1f677434b80763cdd6dc239f214>
{
};

SimpleTreeCanopy::_buildSchema::__l3::<lambda_eccc61c7bc240398106f0c3ec97076bb>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l3::<lambda_eccc61c7bc240398106f0c3ec97076bb>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_9105a6e584fc9f5b2e1653f92d74c379>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_9105a6e584fc9f5b2e1653f92d74c379>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_a0fd6c49d498a24c3b9bbf2f9aa7545f>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_a0fd6c49d498a24c3b9bbf2f9aa7545f>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_1db25be528727c880487320b6fe0653e>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_1db25be528727c880487320b6fe0653e>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_9ee29b475dc6eac67a5ef09bf23aa45c>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_9ee29b475dc6eac67a5ef09bf23aa45c>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_7b952491334165ac96498525aca14203>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_7b952491334165ac96498525aca14203>
{
};

SimpleTreeCanopy::_buildSchema::__l5::<lambda_96fb45bf078dfc128c134291bd87f0ca>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l5::<lambda_96fb45bf078dfc128c134291bd87f0ca>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_38fd965631aa6711f037f9057add2524>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_38fd965631aa6711f037f9057add2524>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_115e85a690f241af304488eebedeb75b>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_115e85a690f241af304488eebedeb75b>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_8088bcbb51f3e94fa86fc3e4425ccd25>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_8088bcbb51f3e94fa86fc3e4425ccd25>
{
};

SimpleTreeCanopy::_buildSchema::__l4::<lambda_f0c0b10dbc699410ad3ed1c03f581df4>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l4::<lambda_f0c0b10dbc699410ad3ed1c03f581df4>
{
};

SimpleTreeCanopy::_buildSchema::__l4::<lambda_b1ed281f6e775bfc2d4f3f8e4f04ba1c>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l4::<lambda_b1ed281f6e775bfc2d4f3f8e4f04ba1c>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_6108a2c04376bc528045d0627f45713d>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_6108a2c04376bc528045d0627f45713d>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_c670f8d9a276d5fde9772c8a3b6e2d11>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_c670f8d9a276d5fde9772c8a3b6e2d11>
{
};

SimpleTreeCanopy::_buildSchema::__l3::<lambda_aec916c82bceefd18b7ad1999ca05487>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l3::<lambda_aec916c82bceefd18b7ad1999ca05487>
{
};

SimpleTreeCanopy::_buildSchema::__l3::<lambda_0007908e8fc98706aac256d2be0c4318>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l3::<lambda_0007908e8fc98706aac256d2be0c4318>
{
};

ScatteredFeaturePiece

struct __cppobj ScatteredFeaturePiece : StructurePiece
{
  int mWidth;
  int mHeight;
  int mDepth;
  int mHeightPosition;
};

ScatteredFeaturePiece_vtbl

struct /*VFT*/ ScatteredFeaturePiece_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SwamplandHut

struct __cppobj __declspec(align(8)) SwamplandHut : ScatteredFeaturePiece
{
  bool mSpawnedWitch;
};

SwamplandHut_vtbl

struct /*VFT*/ SwamplandHut_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

StrongholdPiece_vtbl

struct /*VFT*/ StrongholdPiece_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHStairsDown

struct __cppobj __declspec(align(8)) SHStairsDown : StrongholdPiece
{
  bool isSource;
};

SHStairsDown_vtbl

struct /*VFT*/ SHStairsDown_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHPortalRoom

struct __cppobj __declspec(align(8)) SHPortalRoom : StrongholdPiece
{
  bool hasPlacedMobSpawner;
};

SHPortalRoom_vtbl

struct /*VFT*/ SHPortalRoom_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHStartPiece

struct __cppobj SHStartPiece : SHStairsDown
{
  std::vector<StructurePiece *> pendingChildren;
  SHPortalRoom *portalRoom;
  std::string imposedPiece;
  std::string previousPiece;
  std::vector<PieceWeight> pieceWeights;
};

SHStartPiece_vtbl

struct /*VFT*/ SHStartPiece_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHChestCorridor

struct __cppobj __declspec(align(8)) SHChestCorridor : StrongholdPiece
{
  bool hasPlacedChest;
};

SHChestCorridor_vtbl

struct /*VFT*/ SHChestCorridor_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHFillerCorridor

struct __cppobj __declspec(align(8)) SHFillerCorridor : StrongholdPiece
{
  int steps;
};

SHFillerCorridor_vtbl

struct /*VFT*/ SHFillerCorridor_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHFiveCrossing

struct __cppobj __declspec(align(8)) SHFiveCrossing : StrongholdPiece
{
  bool leftHigh;
  bool leftLow;
  bool rightHigh;
  bool rightLow;
};

SHFiveCrossing_vtbl

struct /*VFT*/ SHFiveCrossing_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHLeftTurn

struct __cppobj SHLeftTurn : StrongholdPiece
{
};

SHLeftTurn_vtbl

struct /*VFT*/ SHLeftTurn_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHRightTurn

struct __cppobj SHRightTurn : StrongholdPiece
{
};

SHRightTurn_vtbl

struct /*VFT*/ SHRightTurn_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHLibrary

struct __cppobj __declspec(align(8)) SHLibrary : StrongholdPiece
{
  bool isTall;
};

SHLibrary_vtbl

struct /*VFT*/ SHLibrary_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHPrisonHall

struct __cppobj SHPrisonHall : StrongholdPiece
{
};

SHPrisonHall_vtbl

struct /*VFT*/ SHPrisonHall_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHRoomCrossing

struct __cppobj __declspec(align(8)) SHRoomCrossing : StrongholdPiece
{
  int type;
};

SHRoomCrossing_vtbl

struct /*VFT*/ SHRoomCrossing_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHStraight

struct __cppobj __declspec(align(8)) SHStraight : StrongholdPiece
{
  bool leftChild;
  bool rightChild;
};

SHStraight_vtbl

struct /*VFT*/ SHStraight_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SHStraightStairsDown

struct __cppobj SHStraightStairsDown : StrongholdPiece
{
};

SHStraightStairsDown_vtbl

struct /*VFT*/ SHStraightStairsDown_vtbl
{
  void (__fastcall *~StructurePiece)(StructurePiece *this);
  void (__fastcall *moveBoundingBox)(StructurePiece *this, int, int, int);
  PoolElementStructurePiece *(__fastcall *asPoolElement)(StructurePiece *this);
  StructurePieceType (__fastcall *getType)(StructurePiece *this);
  void (__fastcall *addChildren)(StructurePiece *this, StructurePiece *, std::vector<std::unique_ptr<StructurePiece>> *, Random *);
  bool (__fastcall *postProcess)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  void (__fastcall *postProcessMobsAt)(StructurePiece *this, BlockSource *, Random *, const BoundingBox *);
  int (__fastcall *getWorldX)(StructurePiece *this, int, int);
  int (__fastcall *getWorldZ)(StructurePiece *this, int, int);
  void (__fastcall *placeBlock)(StructurePiece *this, BlockSource *, const Block *, int, int, int, const BoundingBox *);
  void (__fastcall *generateBox)(StructurePiece *this, BlockSource *, const BoundingBox *, int, int, int, int, int, int, const Block *, const Block *, bool);
  void (__fastcall *addHardcodedSpawnAreas)(StructurePiece *this, LevelChunk *);
};

SmoothStoneSelector

struct __cppobj SmoothStoneSelector : BlockSelector
{
};

SmoothStoneSelector_vtbl

struct /*VFT*/ SmoothStoneSelector_vtbl
{
  void (__fastcall *~BlockSelector)(BlockSelector *this);
  const Block *(__fastcall *next)(BlockSelector *this, Random *, int, int, int, bool);
};

SharedCounter<EndCrystalItem>

struct __cppobj SharedCounter<EndCrystalItem>
{
  EndCrystalItem *ptr;
  std::atomic<int> share_count;
  std::atomic<int> weak_count;
};

SharedPtr<EndCrystalItem>

struct __cppobj SharedPtr<EndCrystalItem>
{
  SharedCounter<EndCrystalItem> *pc;
};

SharedCounter<EndGatewayBlock>

struct __cppobj SharedCounter<EndGatewayBlock>
{
  EndGatewayBlock *ptr;
  std::atomic<int> share_count;
  std::atomic<int> weak_count;
};

SoundChannelFMOD

struct __cppobj SoundChannelFMOD
{
};

SoundSystemFMOD::_addToSoundCache::__l5::<lambda_cae3fd833bb655085bfe054d224c3470>::()::__l2::<lambda_9b09a02bff452da82691cbf9ff79d1cd>

struct __cppobj SoundSystemFMOD::_addToSoundCache::__l5::<lambda_cae3fd833bb655085bfe054d224c3470>::()::__l2::<lambda_9b09a02bff452da82691cbf9ff79d1cd>
{
  FMOD::System *system;
};

SoundSystemFMOD::_updateMusicStatus::__l5::<lambda_8360d204e655f2c1c10b888daad4dfc3>

struct __cppobj SoundSystemFMOD::_updateMusicStatus::__l5::<lambda_8360d204e655f2c1c10b888daad4dfc3>
{
  SoundSystemFMOD *const __this;
};

SoundSystemFMOD::stopMusic::__l8::<lambda_6ef4ca1ed178cf81809ef2edf360f6ea>

struct __cppobj SoundSystemFMOD::stopMusic::__l8::<lambda_6ef4ca1ed178cf81809ef2edf360f6ea>
{
  SoundSystemFMOD *const __this;
};

SoundSystemFMOD::loadRawFromMemory::__l8::<lambda_5bb05d132cbf8074618a264696cff1ab>

struct __cppobj SoundSystemFMOD::loadRawFromMemory::__l8::<lambda_5bb05d132cbf8074618a264696cff1ab>
{
  int numchannels;
  int defaultfrequency;
  SoundFormat format;
};

SoundSystemFMOD::loadAsync::__l43::<lambda_9e3fdf78c49eb3088301e0fd4fc6aa36>

struct __cppobj SoundSystemFMOD::loadAsync::__l43::<lambda_9e3fdf78c49eb3088301e0fd4fc6aa36>
{
  std::shared_ptr<Bedrock::Threading::AsyncDeferredResultT<bool> > resultTask;
  const Core::Path soundName;
  SoundSystemFMOD *const __this;
  std::shared_ptr<Bedrock::Threading::IAsyncResult<std::string > > ioTask;
};

SoundSystemFMOD::_handleLooping::__l2::<lambda_b390fbefbce80ef595f22443b108ead0>

struct __cppobj SoundSystemFMOD::_handleLooping::__l2::<lambda_b390fbefbce80ef595f22443b108ead0>
{
  SoundSystemFMOD *const __this;
  unsigned __int64 soundHandle;
};

savable_state

struct savable_state
{
  int put_buffer;
  int put_bits;
  int last_dc_val[4];
};

StrAndBool

struct __declspec(align(8)) StrAndBool
{
  char *str;
  bool b;
};

ServiceOverrider<bool (__cdecl*)(AssertHandlerContext const &)>::ScopedOverrider

struct __cppobj ServiceOverrider<bool (__cdecl*)(AssertHandlerContext const &)>::ScopedOverrider
{
  ServiceOverrider<bool (__cdecl*)(AssertHandlerContext const &)> *mOverrider;
};

SFAT::FATCellValueType

struct __cppobj SFAT::FATCellValueType
{
  unsigned int mPrev;
  unsigned int mNext;
};

SFAT::FileDescriptorRecord

const struct __cppobj SFAT::FileDescriptorRecord
{
  char mEntityName[128];
  unsigned int mAttributes;
  unsigned int mUniqueID;
  unsigned __int64 mFileSize;
  unsigned int mStartCluster;
  unsigned int mCRC;
  __int64 mTimeCreated;
  __int64 mTimeModified;
  unsigned int mLastCluster;
  unsigned int mOldClusterTrace;
};

SFAT::FileBase

struct __cppobj __declspec(align(8)) SFAT::FileBase
{
  SFAT::FileBase_vtbl *__vftable /*VFT*/;
  SFAT::FileStorageBase *mFileStorage;
  unsigned int mAccessMode;
};

SFAT::FileBase_vtbl

struct /*VFT*/ SFAT::FileBase_vtbl
{
  void (__fastcall *~FileBase)(SFAT::FileBase *this);
  bool (__fastcall *isOpen)(SFAT::FileBase *this);
  SFAT::ErrorCode (__fastcall *close)(SFAT::FileBase *this);
  SFAT::ErrorCode (__fastcall *read)(SFAT::FileBase *this, void *, unsigned __int64, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *write)(SFAT::FileBase *this, const void *, unsigned __int64, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *readAtPosition)(SFAT::FileBase *this, void *, unsigned __int64, __int64, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *writeAtPosition)(SFAT::FileBase *this, const void *, unsigned __int64, __int64, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *seek)(SFAT::FileBase *this, __int64, SFAT::SeekMode);
  SFAT::ErrorCode (__fastcall *getPosition)(SFAT::FileBase *this, __int64 *);
  SFAT::ErrorCode (__fastcall *getSize)(SFAT::FileBase *this, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *flush)(SFAT::FileBase *this);
  SFAT::ErrorCode (__fastcall *open)(SFAT::FileBase *this, const char *, const char *);
  SFAT::ErrorCode (__fastcall *open)(SFAT::FileBase *this, const char *, unsigned int);
};

SFAT::FileStorageBase

struct __cppobj SFAT::FileStorageBase
{
  SFAT::FileStorageBase_vtbl *__vftable /*VFT*/;
};

SFAT::FileStorageBase_vtbl

struct /*VFT*/ SFAT::FileStorageBase_vtbl
{
  void (__fastcall *~FileStorageBase)(SFAT::FileStorageBase *this);
  bool (__fastcall *fileExists)(SFAT::FileStorageBase *this, const char *);
  bool (__fastcall *directoryExists)(SFAT::FileStorageBase *this, const char *);
  bool (__fastcall *fileOrDirectoryExists)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *deleteFile)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *removeDirectory)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *createDirectory)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *renameFile)(SFAT::FileStorageBase *this, const char *, const char *);
  SFAT::ErrorCode (__fastcall *renameDirectory)(SFAT::FileStorageBase *this, const char *, const char *);
  SFAT::ErrorCode (__fastcall *getFileSize)(SFAT::FileStorageBase *this, const char *, unsigned __int64 *);
  bool (__fastcall *isFile)(SFAT::FileStorageBase *this, const char *);
  bool (__fastcall *isDirectory)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *iterateThroughDirectory)(SFAT::FileStorageBase *this, const char *, unsigned int, std::function<enum SFAT::ErrorCode __cdecl(bool &,SFAT::FileDescriptorRecord const &,std::string const &)>);
  SFAT::ErrorCode (__fastcall *getFreeSpace)(SFAT::FileStorageBase *this, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *createFileImpl)(SFAT::FileStorageBase *this, std::shared_ptr<SFAT::FileBase> *);
};

SFAT::FileHandle

struct __cppobj SFAT::FileHandle
{
  std::shared_ptr<SFAT::FileBase> mFileImpl;
};

SFAT::SplitFATConfigurationBase

struct __cppobj __declspec(align(8)) SFAT::SplitFATConfigurationBase
{
  SFAT::SplitFATConfigurationBase_vtbl *__vftable /*VFT*/;
  volatile bool mIsReady;
};

SFAT::BlockVirtualizationHeader

struct __cppobj SFAT::BlockVirtualizationHeader
{
  unsigned __int16 verificationCode;
  unsigned __int8 id;
  unsigned __int8 headerSize;
  unsigned __int8 virtualBlocksCount;
  unsigned __int8 scratchBlockIndex;
  unsigned int dataCRC;
  unsigned int headerCRC;
};

SFAT::BlockVirtualizationDescriptor

struct __cppobj SFAT::BlockVirtualizationDescriptor
{
  SFAT::BlockVirtualizationHeader header;
  unsigned __int8 blockIndices[64];
};

SFAT::VolumeDescriptorExtraParameters

struct __cppobj SFAT::VolumeDescriptorExtraParameters
{
  SFAT::BlockVirtualizationDescriptor descriptors[2];
};

SFAT::VolumeDescriptor

struct __cppobj SFAT::VolumeDescriptor
{
  unsigned int mVolumeVerificationCode;
  unsigned int mVersion;
  unsigned int mVolumeDescriptorSize;
  unsigned int mVolumeControlDataSize;
  unsigned int mBlockControlDataSize;
  unsigned int mMaxBlocksCount;
  unsigned int mFirstClusterOffset;
  unsigned int mClusterSizeInBytes;
  unsigned int mChunkSizeInBytes;
  unsigned int mBytesPerVolumeBlock;
  unsigned int mFATCopies;
  unsigned int mFirstFileDataBlockIndex;
  unsigned int mFlags;
  unsigned int mFileDescriptorRecordStorageSize;
  unsigned int mMaxFileNameLength;
  unsigned int mBytesPerSymbol;
  $9C8DDCC8F5E8C56759E7410EBD92952D ___u16;
};

SFAT::BitSet

struct __cppobj SFAT::BitSet
{
  unsigned __int64 mSize;
  std::vector<unsigned __int64> mElements;
};

SFAT::FATBlock

struct __cppobj __declspec(align(8)) SFAT::FATBlock
{
  const SFAT::VolumeDescriptor *mVolumeDescriptor;
  unsigned int mBlockIndex;
  unsigned int mStartClusterIndex;
  unsigned int mEndClusterIndex;
  std::vector<SFAT::FATCellValueType> mTable;
  SFAT::BitSet mFreeClustersBitSet;
  bool mIsCacheInSync;
};

SFAT::VolumeManager

struct __cppobj __declspec(align(8)) SFAT::VolumeManager
{
  SFAT::VolumeDescriptor mVolumeDescriptor;
  std::unique_ptr<SFAT::FATDataManager> mFATDataManager;
  std::unique_ptr<SFAT::DataBlockManager> mDataBlockManager;
  SFAT::SFATMutex mVolumeExpansionMutex;
  SFAT::VolumeControlData mVolumeControlData;
  std::shared_ptr<SFAT::SplitFATConfigurationBase> mLowLevelAccess;
  SFAT::TransactionEventsLog mTransaction;
  SFAT::BlockVirtualization mBlockVirtualization;
  SFAT::FileSystemState mState;
};

SFAT::SFATMutex

struct __cppobj SFAT::SFATMutex
{
  std::mutex mMutex;
  volatile bool mLocked;
  std::thread::id mThreadId;
};

SFAT::FATDataManager

struct __cppobj SFAT::FATDataManager
{
  const SFAT::VolumeDescriptor *mVolumeDescriptor;
  std::vector<std::unique_ptr<SFAT::FATBlock>> mFATBlocksCache;
  SFAT::VolumeManager *mVolumeManager;
  SFAT::SFATMutex mFATBlockReadWriteMutex;
};

SFAT::ClusterDataCache

struct __cppobj __declspec(align(8)) SFAT::ClusterDataCache
{
  unsigned int mClusterIndex;
  std::vector<unsigned char> mBuffer;
  bool mIsCacheInSync;
};

SFAT::DataBlockManager

struct __cppobj SFAT::DataBlockManager
{
  SFAT::VolumeManager *mVolumeManager;
  unsigned int mClustersPerFATBlock;
  unsigned int mMaxPossibleBlocksCount;
  unsigned __int64 mClusterSize;
  unsigned __int64 mDataBlockSize;
  std::map<unsigned int,SFAT::ClusterDataCache> mCachedClusters;
  SFAT::SFATMutex mClusterReadWriteMutex;
};

SFAT::VolumeControlData

struct __cppobj SFAT::VolumeControlData
{
  volatile unsigned int mCountAllocatedDataBlocks;
  volatile unsigned int mCountAllocatedFATBlocks;
  volatile unsigned int mCountTotalDataClusters;
};

SFAT::TransactionEvent

struct SFAT::TransactionEvent
{
  SFAT::TransactionEventType mEventType;
  $D35D2DBDCE7D4A8DBDCD409945A10809 ___u1;
  unsigned int mCRC;
};

SFAT::TransactionEventsLog

struct __cppobj SFAT::TransactionEventsLog
{
  SFAT::VolumeManager *mVolumeManager;
  std::unordered_map<unsigned int,SFAT::TransactionEvent> mFATBlockChanges;
  std::unordered_map<unsigned int,SFAT::TransactionEvent> mFileClusterChanges;
  std::unordered_map<unsigned int,SFAT::TransactionEvent> mDirectoryClusterChanges;
  bool mIsInTransaction;
  std::vector<unsigned char> mClusterDataBuffer;
};

SFAT::BlockVirtualization

struct __cppobj SFAT::BlockVirtualization
{
  SFAT::VolumeManager *mVolumeManager;
  unsigned __int64 mDescriptorIndex;
};

SFAT::DataPlacementStrategyBase

struct __cppobj __declspec(align(8)) SFAT::DataPlacementStrategyBase
{
  SFAT::DataPlacementStrategyBase_vtbl *__vftable /*VFT*/;
  SFAT::VolumeManager *mVolumeManager;
  SFAT::VirtualFileSystem *mVirtualFileSystem;
  bool mIsActive;
};

SFAT::DataPlacementStrategyBase_vtbl

struct /*VFT*/ SFAT::DataPlacementStrategyBase_vtbl
{
  void (__fastcall *~DataPlacementStrategyBase)(SFAT::DataPlacementStrategyBase *this);
  SFAT::ErrorCode (__fastcall *prepareForWriteTransaction)(SFAT::DataPlacementStrategyBase *this);
  SFAT::ErrorCode (__fastcall *performDefragmentaionOnTransactionEnd)(SFAT::DataPlacementStrategyBase *this);
  SFAT::ErrorCode (__fastcall *findFreeCluster)(SFAT::DataPlacementStrategyBase *this, unsigned int *, bool);
};

SFAT::RecoveryManager

struct __cppobj SFAT::RecoveryManager
{
  SFAT::RecoveryManager_vtbl *__vftable /*VFT*/;
  SFAT::VolumeManager *mVolumeManager;
  SFAT::VirtualFileSystem *mVirtualFileSystem;
  std::vector<unsigned char> mClusterDataBuffer;
  std::vector<SFAT::CellTestResult> mCellsWithProblem;
  std::vector<SFAT::ClusterChainTestResult> mClusterChainsWithProblem;
};

SFAT::RecoveryManager_vtbl

struct /*VFT*/ SFAT::RecoveryManager_vtbl
{
  void (__fastcall *~RecoveryManager)(SFAT::RecoveryManager *this);
};

SFAT::VirtualFileSystem

struct __cppobj SFAT::VirtualFileSystem
{
  SFAT::VolumeManager mVolumeManager;
  bool mIsValid;
  std::unique_ptr<SFAT::RecoveryManager> mRecoveryManager;
  unsigned int mClusterSize;
  std::unique_ptr<SFAT::MemoryBufferPool> mMemoryBufferPool;
  std::shared_ptr<SFAT::DataPlacementStrategyBase> mDefragmentation;
};

SFAT::CellTestResult

struct SFAT::CellTestResult
{
  SFAT::IntegrityStatus mStatus;
  unsigned int mClusterIndex;
  unsigned int mRecordIndex;
};

SFAT::DescriptorLocation

struct SFAT::DescriptorLocation
{
  unsigned int mDirectoryStartClusterIndex;
  unsigned int mDescriptorClusterIndex;
  unsigned int mRecordIndex;
};

SFAT::ClusterChainTestResult

struct SFAT::ClusterChainTestResult
{
  SFAT::IntegrityStatus mStatus;
  unsigned int mClusterIndex;
  SFAT::DescriptorLocation mLocation;
};

SFAT::MemoryBufferPool

struct __cppobj __declspec(align(8)) SFAT::MemoryBufferPool
{
  std::vector<std::unique_ptr<std::vector<unsigned char>>> mFreeResourceBlocks;
  const unsigned __int64 mBufferSize;
  SFAT::SFATMutex mBufferUpdates;
  const unsigned __int64 mRecommendedReourceMaxCount;
  volatile int mTotalCountUsed;
};

SFAT::SplitFATConfigurationBase_vtbl

struct /*VFT*/ SFAT::SplitFATConfigurationBase_vtbl
{
  void (__fastcall *~SplitFATConfigurationBase)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *shutdown)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *create)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *open)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *close)(SFAT::SplitFATConfigurationBase *this);
  SFAT::FileHandle *(__fastcall *getClusterDataFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *result, int);
  SFAT::FileHandle *(__fastcall *getFATDataFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *result, int);
  SFAT::ErrorCode (__fastcall *remove)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *flushFATDataFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *flushClusterDataFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *allocateDataBlock)(SFAT::SplitFATConfigurationBase *this, SFAT::VolumeManager *, unsigned int);
  SFAT::ErrorCode (__fastcall *defragmentationOnTransactionEnd)(SFAT::SplitFATConfigurationBase *this);
  bool (__fastcall *clusterDataFileExists)(SFAT::SplitFATConfigurationBase *this);
  bool (__fastcall *fatDataFileExists)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *createDataPlacementStrategy)(SFAT::SplitFATConfigurationBase *this, std::shared_ptr<SFAT::DataPlacementStrategyBase> *, SFAT::VolumeManager *, SFAT::VirtualFileSystem *);
  bool (__fastcall *isTransactionSupported)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *createTransactionFiles)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *tryOpenDirectoryTransactionFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *);
  SFAT::ErrorCode (__fastcall *tryOpenDataTransactionFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *);
  SFAT::ErrorCode (__fastcall *cleanupDirectoryTransactionFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *cleanupDataTransactionFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *cleanupTempTransactionFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *finalizeTransactionFile)(SFAT::SplitFATConfigurationBase *this);
  void (__fastcall *getTempTransactionFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *);
  void (__fastcall *getDirectoryTransactionFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *);
};

SFAT::SFATRecursiveMutex

struct __cppobj SFAT::SFATRecursiveMutex
{
  std::recursive_mutex mMutex;
  std::atomic<int> mLockCount;
  std::thread::id mThreadId;
};

SFAT::SplitFATFileStorage

struct __cppobj SFAT::SplitFATFileStorage : SFAT::FileStorageBase
{
  std::unique_ptr<SFAT::VirtualFileSystem> mVirtualFileSystem;
  SFAT::SFATRecursiveMutex mTransactionMutex;
};

SFAT::SplitFATFileStorage_vtbl

struct /*VFT*/ SFAT::SplitFATFileStorage_vtbl
{
  void (__fastcall *~FileStorageBase)(SFAT::FileStorageBase *this);
  bool (__fastcall *fileExists)(SFAT::FileStorageBase *this, const char *);
  bool (__fastcall *directoryExists)(SFAT::FileStorageBase *this, const char *);
  bool (__fastcall *fileOrDirectoryExists)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *deleteFile)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *removeDirectory)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *createDirectory)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *renameFile)(SFAT::FileStorageBase *this, const char *, const char *);
  SFAT::ErrorCode (__fastcall *renameDirectory)(SFAT::FileStorageBase *this, const char *, const char *);
  SFAT::ErrorCode (__fastcall *getFileSize)(SFAT::FileStorageBase *this, const char *, unsigned __int64 *);
  bool (__fastcall *isFile)(SFAT::FileStorageBase *this, const char *);
  bool (__fastcall *isDirectory)(SFAT::FileStorageBase *this, const char *);
  SFAT::ErrorCode (__fastcall *iterateThroughDirectory)(SFAT::FileStorageBase *this, const char *, unsigned int, std::function<enum SFAT::ErrorCode __cdecl(bool &,SFAT::FileDescriptorRecord const &,std::string const &)>);
  SFAT::ErrorCode (__fastcall *getFreeSpace)(SFAT::FileStorageBase *this, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *createFileImpl)(SFAT::FileStorageBase *this, std::shared_ptr<SFAT::FileBase> *);
};

StbiFile

struct __cppobj StbiFile
{
  Core::File mFile;
};

SaveGameSecureStorage

struct __cppobj __declspec(align(8)) SaveGameSecureStorage : SecureStorage
{
  std::string mSettingsPath;
  Json::Value mJsonValue;
  bool mInitialized;
};

SaveGameSecureStorage_vtbl

struct /*VFT*/ SaveGameSecureStorage_vtbl
{
  void (__fastcall *~SecureStorage)(SecureStorage *this);
  bool (__fastcall *add)(SecureStorage *this, const std::string *, const std::string *);
  bool (__fastcall *addOrUpdate)(SecureStorage *this, const std::string *, const std::string *);
  bool (__fastcall *remove)(SecureStorage *this, const std::string *);
  bool (__fastcall *get)(SecureStorage *this, const std::string *, std::string *);
};

stbi__huffman

struct stbi__huffman
{
  unsigned __int8 fast[512];
  unsigned __int16 code[256];
  unsigned __int8 values[256];
  unsigned __int8 size[257];
  unsigned int maxcode[18];
  int delta[17];
};

stbi__jpeg::<unnamed_type_img_comp>

struct stbi__jpeg::<unnamed_type_img_comp>
{
  int id;
  int h;
  int v;
  int tq;
  int hd;
  int ha;
  int dc_pred;
  int x;
  int y;
  int w2;
  int h2;
  unsigned __int8 *data;
  void *raw_data;
  void *raw_coeff;
  unsigned __int8 *linebuf;
  __int16 *coeff;
  int coeff_w;
  int coeff_h;
};

stbi__jpeg

struct stbi__jpeg
{
  stbi__context *s;
  stbi__huffman huff_dc[4];
  stbi__huffman huff_ac[4];
  unsigned __int16 dequant[4][64];
  __int16 fast_ac[4][512];
  int img_h_max;
  int img_v_max;
  int img_mcu_x;
  int img_mcu_y;
  int img_mcu_w;
  int img_mcu_h;
  stbi__jpeg::<unnamed_type_img_comp> img_comp[4];
  unsigned int code_buffer;
  int code_bits;
  unsigned __int8 marker;
  int nomore;
  int progressive;
  int spec_start;
  int spec_end;
  int succ_high;
  int succ_low;
  int eob_run;
  int jfif;
  int app14_color_transform;
  int rgb;
  int scan_n;
  int order[4];
  int restart_interval;
  int todo;
  void (__fastcall *idct_block_kernel)(unsigned __int8 *, int, __int16 *);
  void (__fastcall *YCbCr_to_RGB_kernel)(unsigned __int8 *, const unsigned __int8 *, const unsigned __int8 *, const unsigned __int8 *, int, int);
  unsigned __int8 *(__fastcall *resample_row_hv_2_kernel)(unsigned __int8 *, unsigned __int8 *, unsigned __int8 *, int, int);
};

stbi__resample

struct __declspec(align(8)) stbi__resample
{
  unsigned __int8 *(__fastcall *resample)(unsigned __int8 *, unsigned __int8 *, unsigned __int8 *, int, int);
  unsigned __int8 *line0;
  unsigned __int8 *line1;
  int hs;
  int vs;
  int w_lores;
  int ystep;
  int ypos;
};

stbi__pngchunk

struct stbi__pngchunk
{
  unsigned int length;
  unsigned int type;
};

stbi__pic_packet

struct stbi__pic_packet
{
  unsigned __int8 size;
  unsigned __int8 type;
  unsigned __int8 channel;
};

stbir__contributors

struct stbir__contributors
{
  int n0;
  int n1;
};

ShareableLock

struct __cppobj ShareableLock
{
  std::shared_timed_mutex mMutex;
};

ShareableLock::ScopedUnique

struct __cppobj ShareableLock::ScopedUnique
{
  ShareableLock *mLk;
};

ShareableLock::ScopedShared

struct __cppobj ShareableLock::ScopedShared
{
  ShareableLock *mLk;
};

StopwatchNLast

struct __cppobj StopwatchNLast : Stopwatch
{
  int n;
  int k;
  std::vector<double> t;
  long double sum;
  Stopwatch sw;
};

StopwatchNLast_vtbl

struct /*VFT*/ StopwatchNLast_vtbl
{
  void (__fastcall *~Stopwatch)(Stopwatch *this);
  long double (__fastcall *stop)(Stopwatch *this);
  long double (__fastcall *stopContinue)(Stopwatch *this);
  void (__fastcall *print)(Stopwatch *this, const std::string *);
};

ScopeWatchdog

struct __cppobj ScopeWatchdog
{
  const std::string mName;
  std::chrono::duration<__int64,std::ratio<1,1000> > mTimeLimit;
  bool mLogAlways;
  std::chrono::time_point<std::chrono::steady_clock,std::chrono::duration<__int64,std::ratio<1,1000000000> > > mStartTime;
};

SFAT::CRC32

struct __cppobj SFAT::CRC32
{
};

SFAT::SFATLockGuard

struct __cppobj SFAT::SFATLockGuard
{
  SFAT::SFATMutex *mMutex;
};

SFAT::MemoryBufferHandle

struct __cppobj SFAT::MemoryBufferHandle
{
  SFAT::MemoryBufferPool *mMemoryBufferPool;
  std::unique_ptr<std::vector<unsigned char>> mObject;
};

SFAT::PathString

struct __cppobj SFAT::PathString
{
  std::string mPath;
  unsigned __int64 mPosition;
};

SFAT::FileManipulator

struct __cppobj SFAT::FileManipulator
{
  SFAT::FileDescriptorRecord mFileDescriptorRecord;
  SFAT::DescriptorLocation mLocation;
  SFAT::PathString mFullPath;
  unsigned int mAccessMode;
  __int64 mPosition;
  unsigned int mPositionClusterIndex;
  __int64 mNextPosition;
  bool mIsValid;
  std::vector<unsigned char> mBuffer;
};

SFAT::CRC16

struct __cppobj SFAT::CRC16
{
};

SFAT::RecoveryManager::testSingleFileIntegrity::__l8::<lambda_1e070c6a2247d80fbe8c7e14a3aea2dc>

struct __cppobj SFAT::RecoveryManager::testSingleFileIntegrity::__l8::<lambda_1e070c6a2247d80fbe8c7e14a3aea2dc>
{
  unsigned int *counter;
  SFAT::ClusterChainTestResult *result;
  SFAT::FATDataManager *fatMgr;
};

SFAT::SplitFATFile

struct __cppobj SFAT::SplitFATFile : SFAT::FileBase
{
  std::unique_ptr<SFAT::FileManipulator> mFileManipulator;
};

SFAT::SplitFATFile_vtbl

struct /*VFT*/ SFAT::SplitFATFile_vtbl
{
  void (__fastcall *~FileBase)(SFAT::FileBase *this);
  bool (__fastcall *isOpen)(SFAT::FileBase *this);
  SFAT::ErrorCode (__fastcall *close)(SFAT::FileBase *this);
  SFAT::ErrorCode (__fastcall *read)(SFAT::FileBase *this, void *, unsigned __int64, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *write)(SFAT::FileBase *this, const void *, unsigned __int64, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *readAtPosition)(SFAT::FileBase *this, void *, unsigned __int64, __int64, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *writeAtPosition)(SFAT::FileBase *this, const void *, unsigned __int64, __int64, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *seek)(SFAT::FileBase *this, __int64, SFAT::SeekMode);
  SFAT::ErrorCode (__fastcall *getPosition)(SFAT::FileBase *this, __int64 *);
  SFAT::ErrorCode (__fastcall *getSize)(SFAT::FileBase *this, unsigned __int64 *);
  SFAT::ErrorCode (__fastcall *flush)(SFAT::FileBase *this);
  SFAT::ErrorCode (__fastcall *open)(SFAT::FileBase *this, const char *, const char *);
  SFAT::ErrorCode (__fastcall *open)(SFAT::FileBase *this, const char *, unsigned int);
};

SFAT::SplitFATTransactConfiguration

struct __cppobj SFAT::SplitFATTransactConfiguration : SFAT::SplitFATConfigurationBase
{
  SFAT::FileHandle mTempTransactionFile;
  SFAT::FileHandle mDirectoryTransactionFile;
  SFAT::FileHandle mDataTransactionFile;
  std::shared_ptr<SFAT::FileStorageBase> mTransactionFileStorage;
};

SFAT::SplitFATTransactConfiguration_vtbl

struct /*VFT*/ SFAT::SplitFATTransactConfiguration_vtbl
{
  void (__fastcall *~SplitFATConfigurationBase)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *shutdown)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *create)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *open)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *close)(SFAT::SplitFATConfigurationBase *this);
  SFAT::FileHandle *(__fastcall *getClusterDataFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *result, int);
  SFAT::FileHandle *(__fastcall *getFATDataFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *result, int);
  SFAT::ErrorCode (__fastcall *remove)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *flushFATDataFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *flushClusterDataFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *allocateDataBlock)(SFAT::SplitFATConfigurationBase *this, SFAT::VolumeManager *, unsigned int);
  SFAT::ErrorCode (__fastcall *defragmentationOnTransactionEnd)(SFAT::SplitFATConfigurationBase *this);
  bool (__fastcall *clusterDataFileExists)(SFAT::SplitFATConfigurationBase *this);
  bool (__fastcall *fatDataFileExists)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *createDataPlacementStrategy)(SFAT::SplitFATConfigurationBase *this, std::shared_ptr<SFAT::DataPlacementStrategyBase> *, SFAT::VolumeManager *, SFAT::VirtualFileSystem *);
  bool (__fastcall *isTransactionSupported)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *createTransactionFiles)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *tryOpenDirectoryTransactionFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *);
  SFAT::ErrorCode (__fastcall *tryOpenDataTransactionFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *);
  SFAT::ErrorCode (__fastcall *cleanupDirectoryTransactionFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *cleanupDataTransactionFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *cleanupTempTransactionFile)(SFAT::SplitFATConfigurationBase *this);
  SFAT::ErrorCode (__fastcall *finalizeTransactionFile)(SFAT::SplitFATConfigurationBase *this);
  void (__fastcall *getTempTransactionFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *);
  void (__fastcall *getDirectoryTransactionFile)(SFAT::SplitFATConfigurationBase *this, SFAT::FileHandle *);
  const char *(__fastcall *_getDirectoryTransactionFilePath)(SFAT::SplitFATTransactConfiguration *this);
  const char *(__fastcall *_getTempTransactionFilePath)(SFAT::SplitFATTransactConfiguration *this);
  const char *(__fastcall *_getDataTransactionFilePath)(SFAT::SplitFATTransactConfiguration *this);
};

SFAT::TransactionEventsLog::_restoreFromTransactionFile::__l14::<lambda_f464715ebff49e584bad436c62bdaa1e>

struct __cppobj SFAT::TransactionEventsLog::_restoreFromTransactionFile::__l14::<lambda_f464715ebff49e584bad436c62bdaa1e>
{
  SFAT::FileHandle *fileHandle;
  __int64 *position;
  unsigned __int64 *countBytesToRead;
};

SFAT::CRC24

struct __cppobj SFAT::CRC24
{
};

SFAT::VirtualFileSystem::_isDirectoryEmpty::__l2::<lambda_249a999051cf4832137a3f59aaa6c45b>

struct __cppobj SFAT::VirtualFileSystem::_isDirectoryEmpty::__l2::<lambda_249a999051cf4832137a3f59aaa6c45b>
{
  bool *foundEntity;
};

SFAT::VirtualFileSystem::_createEntity::__l2::<lambda_8b7276f0a3e09da4a84a4e133743effd>

struct __cppobj SFAT::VirtualFileSystem::_createEntity::__l2::<lambda_8b7276f0a3e09da4a84a4e133743effd>
{
  unsigned int *selectedRecordIndex;
};

SFAT::VirtualFileSystem::read::__l2::<lambda_c23223065a2b55117ec1766b47f7c2a6>

struct __cppobj SFAT::VirtualFileSystem::read::__l2::<lambda_c23223065a2b55117ec1766b47f7c2a6>
{
  unsigned __int8 **outputBuffer;
  unsigned __int64 *bytesRemainedToCopy;
  unsigned int *clusterReadOffset;
  std::vector<unsigned char> *clusterData;
  unsigned int *countClustersRead;
  unsigned int countClustersToRead;
  SFAT::VirtualFileSystem *const __this;
};

SFAT::VirtualFileSystem::iterateThroughDirectory::__l2::<lambda_cecd217142c34c71fdeb7b761f727b9e>

struct __cppobj SFAT::VirtualFileSystem::iterateThroughDirectory::__l2::<lambda_cecd217142c34c71fdeb7b761f727b9e>
{
  std::function<enum SFAT::ErrorCode __cdecl(bool &,SFAT::FileDescriptorRecord const &,std::string const &)> *callback;
};

SFAT::VirtualFileSystem::_trunc::__l26::<lambda_47ce944f0503b9b4adb1d6cbf279dfdd>

struct __cppobj SFAT::VirtualFileSystem::_trunc::__l26::<lambda_47ce944f0503b9b4adb1d6cbf279dfdd>
{
  const SFAT::DescriptorLocation *location;
  unsigned int newLastClusterIndex;
  SFAT::VirtualFileSystem *const __this;
};

SFAT::VirtualFileSystem::_iterateThroughDirectoryRecursively::__l2::<lambda_ebf0c4dc747ea335e16db93745c87fdb>

struct __cppobj SFAT::VirtualFileSystem::_iterateThroughDirectoryRecursively::__l2::<lambda_ebf0c4dc747ea335e16db93745c87fdb>
{
  SFAT::VirtualFileSystem *const __this;
  unsigned int *flags;
  std::function<enum SFAT::ErrorCode __cdecl(bool &,SFAT::DescriptorLocation const &,SFAT::FileDescriptorRecord const &,std::string const &)> *callback;
};

SFAT::VirtualFileSystem::_getClusterForPosition::__l2::<lambda_25729679247d20f75b7b6e5e2871a905>

struct __cppobj SFAT::VirtualFileSystem::_getClusterForPosition::__l2::<lambda_25729679247d20f75b7b6e5e2871a905>
{
  unsigned int *foundClusterIndex;
  unsigned int *clusterInverseCounter;
};

SFAT::VirtualFileSystem::_renameEntity::__l2::<lambda_d12879e995d60e1f647dd732045a77ba>

struct __cppobj SFAT::VirtualFileSystem::_renameEntity::__l2::<lambda_d12879e995d60e1f647dd732045a77ba>
{
  std::string *newNameStr;
  bool *foundEntity;
};

SFAT::VirtualFileSystem::_getCountClusters::__l2::<lambda_1e9471e70c826f487760fd9bb4988c6e>

struct __cppobj SFAT::VirtualFileSystem::_getCountClusters::__l2::<lambda_1e9471e70c826f487760fd9bb4988c6e>
{
  unsigned int *countClusters;
  unsigned int *lastClusterIndex;
};

SFAT::VirtualFileSystem::write::__l2::<lambda_8ccf35fa49cd2e7a64c0d636e7f3b02a>

struct __cppobj SFAT::VirtualFileSystem::write::__l2::<lambda_8ccf35fa49cd2e7a64c0d636e7f3b02a>
{
  unsigned __int64 *sizeWritten;
  SFAT::FileManipulator *fileManipulator;
  const unsigned __int8 **inputBuffer;
  unsigned __int64 *bytesRemainedToCopy;
  unsigned int *clusterWriteOffset;
  std::vector<unsigned char> *clusterData;
  unsigned int *countClustersWritten;
  unsigned int countClustersToWrite;
  SFAT::VirtualFileSystem *const __this;
};

SFNT_HeaderRec_

struct SFNT_HeaderRec_
{
  unsigned int format_tag;
  unsigned __int16 num_tables;
  unsigned __int16 search_range;
  unsigned __int16 entry_selector;
  unsigned __int16 range_shift;
  unsigned int offset;
};

stbrp__findresult

struct stbrp__findresult
{
  int x;
  int y;
  stbrp_node **prev_link;
};

static_vector<std::weak_ptr<Bedrock::PubSub::Detail::PublisherBase<Bedrock::PubSub::ThreadModel::MultiThreaded,void,void __cdecl(Core::Profile::ProfileGroup &)>::SubscriptionBody>,32>::iterator

struct __cppobj static_vector<std::weak_ptr<Bedrock::PubSub::Detail::PublisherBase<Bedrock::PubSub::ThreadModel::MultiThreaded,void,void __cdecl(Core::Profile::ProfileGroup &)>::SubscriptionBody>,32>::iterator
{
  std::weak_ptr<Bedrock::PubSub::Detail::PublisherBase<Bedrock::PubSub::ThreadModel::MultiThreaded,void,void __cdecl(Core::Profile::ProfileGroup &)>::SubscriptionBody> *mPtr;
};

static_vector<std::weak_ptr<Bedrock::PubSub::Detail::PublisherBase<Bedrock::PubSub::ThreadModel::MultiThreaded,void,void __cdecl(Core::Profile::ProfileGroup &)>::SubscriptionBody>,32>

struct __cppobj static_vector<std::weak_ptr<Bedrock::PubSub::Detail::PublisherBase<Bedrock::PubSub::ThreadModel::MultiThreaded,void,void __cdecl(Core::Profile::ProfileGroup &)>::SubscriptionBody>,32>
{
  std::_Align_type<double,16> mArray[32];
  unsigned __int64 mSize;
};

Serializer::serializePrimaryField::__l2::<lambda_9af6748ea60d8af6979b10ce9c586e9b>

struct __cppobj Serializer::serializePrimaryField::__l2::<lambda_9af6748ea60d8af6979b10ce9c586e9b>
{
  unsigned int kAttributesId;
  entt::meta_any *any;
  Serializer *const __this;
};

starmapobject

struct starmapobject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *func;
  _object *it;
};

stringio

struct stringio
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  wchar_t *buf;
  __int64 pos;
  __int64 string_size;
  unsigned __int64 buf_size;
  char ok;
  char closed;
  char readuniversal;
  char readtranslate;
  _object *decoder;
  _object *readnl;
  _object *writenl;
  _object *dict;
  _object *weakreflist;
};

SemLockObject

struct SemLockObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  void *handle;
  int last_tid;
  int count;
  int maxvalue;
  int kind;
};

SRE_REPEAT_T

struct SRE_REPEAT_T
{
  __int64 count;
  unsigned int *pattern;
  void *last_ptr;
  SRE_REPEAT_T *prev;
};

ScannerObject

struct ScannerObject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *pattern;
  SRE_STATE state;
};

sre_umatch_context

struct sre_umatch_context
{
  __int64 last_ctx_pos;
  __int64 jump;
  wchar_t *ptr;
  unsigned int *pattern;
  __int64 count;
  __int64 lastmark;
  __int64 lastindex;
  union
  {
    unsigned int chr;
    SRE_REPEAT_T *rep;
  } u;
};

sre_match_context

struct sre_match_context
{
  __int64 last_ctx_pos;
  __int64 jump;
  unsigned __int8 *ptr;
  unsigned int *pattern;
  __int64 count;
  __int64 lastmark;
  __int64 lastindex;
  union
  {
    unsigned int chr;
    SRE_REPEAT_T *rep;
  } u;
};

staticmethod

struct staticmethod
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *sm_callable;
};

seqiterobject

struct seqiterobject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  int it_index;
  _object *it_seq;
};

sortwrapperobject

struct sortwrapperobject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _object *key;
  _object *value;
};

setiterobject

struct setiterobject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _setobject *si_set;
  __int64 si_used;
  __int64 si_pos;
  __int64 len;
};

superobject

struct superobject
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  _typeobject *type;
  _object *obj;
  _typeobject *obj_type;
};

stackentry

struct stackentry
{
  int s_state;
  dfa *s_dfa;
  _node *s_parent;
};

stack

struct stack
{
  stackentry *s_top;
  stackentry s_base[1500];
};

sp_handle_object

struct sp_handle_object
{
  __int64 ob_refcnt;
  _typeobject *ob_type;
  void *handle;
};

ShadersLibrary

struct __cppobj ShadersLibrary
{
  std::map<std::wstring,unsigned int> shaderCacheMap;
  std::vector<void *> loadedShadersData;
  unsigned int storedShaderCount;
  CustomBlob *shaderCache;
  unsigned __int64 xorKeyLength;
  unsigned __int64 xorKeyCurrentOffset;
};

SliderComponent::_updateSliderBarProgress::__l2::<lambda_0fa219b87a373a09d30835719138e33a>

struct __cppobj SliderComponent::_updateSliderBarProgress::__l2::<lambda_0fa219b87a373a09d30835719138e33a>
{
};

StorageDependencyScreenController::_registerBindings::__l2::<lambda_abc0411e58cca189896914892e40c16b>::()::__l6::<lambda_15b24bd133e958d68a060ebbc5b1ece6>

struct __cppobj StorageDependencyScreenController::_registerBindings::__l2::<lambda_abc0411e58cca189896914892e40c16b>::()::__l6::<lambda_15b24bd133e958d68a060ebbc5b1ece6>
{
  PackContentItem *const content;
};

StartMenuScreenController::onOpen::__l5::<lambda_1574bd2e3698b4f242153fd310cd920b>

struct __cppobj StartMenuScreenController::onOpen::__l5::<lambda_1574bd2e3698b4f242153fd310cd920b>
{
  StartMenuScreenController *const __this;
  const GamePadRemappingLayout *gamepadRemapping;
};

StorageDependencyScreenController::_populateAllDependencies::__l2::<lambda_50ff95644bda46b030d63d05eaa74932>

struct __cppobj StorageDependencyScreenController::_populateAllDependencies::__l2::<lambda_50ff95644bda46b030d63d05eaa74932>
{
  StorageDependencyScreenController *const __this;
};

ServerFormBindingInformation::createBindingData::__l2::<lambda_5877bbc18e65de1799e21a4d6baf222e>

struct __cppobj ServerFormBindingInformation::createBindingData::__l2::<lambda_5877bbc18e65de1799e21a4d6baf222e>
{
  ServerFormBindingInformation *const __this;
};

SubscriptionsScreenController::tick::__l11::<lambda_1109a751a3b331261c66bffc74b4c0d6>

struct __cppobj SubscriptionsScreenController::tick::__l11::<lambda_1109a751a3b331261c66bffc74b4c0d6>
{
};

SubscriptionsScreenController::tick::__l11::<lambda_3405681c330be99db571a029a5de6d5e>

struct __cppobj SubscriptionsScreenController::tick::__l11::<lambda_3405681c330be99db571a029a5de6d5e>
{
};

SubscriptionsScreenController::_getRealmSubscriptionFromWorld::__l2::<lambda_5cdf67128f3bea6159dd8fc163d38d57>::()::__l8::<lambda_87d887136041d2858ff416203462d397>

struct __cppobj SubscriptionsScreenController::_getRealmSubscriptionFromWorld::__l2::<lambda_5cdf67128f3bea6159dd8fc163d38d57>::()::__l8::<lambda_87d887136041d2858ff416203462d397>
{
  const Realms::RealmId *realmId;
};

SubscriptionsScreenController::_getRealmSubscriptionFromWorld::__l2::<lambda_5cdf67128f3bea6159dd8fc163d38d57>::()::__l17::<lambda_bae8d35094fb397bedc67c3ba62ad721>

struct __cppobj SubscriptionsScreenController::_getRealmSubscriptionFromWorld::__l2::<lambda_5cdf67128f3bea6159dd8fc163d38d57>::()::__l17::<lambda_bae8d35094fb397bedc67c3ba62ad721>
{
  const Realms::RealmId *realmId;
};

ScreenView::_updateControlCollections::__l36::<lambda_803420e90046a466ebce054da63600a8>

struct __cppobj ScreenView::_updateControlCollections::__l36::<lambda_803420e90046a466ebce054da63600a8>
{
  std::vector<std::shared_ptr<UIControl>> *controlsToRemove;
};

SceneStack::flushStack::__l5::<lambda_08197decf7f176c94b189045c2e91557>

struct __cppobj SceneStack::flushStack::__l5::<lambda_08197decf7f176c94b189045c2e91557>
{
  SceneStack *const __this;
};

ScreenView::_handleDirtyVisualTree::__l50::<lambda_2111019e43bda338732d87a7a0c5b0ae>

struct __cppobj ScreenView::_handleDirtyVisualTree::__l50::<lambda_2111019e43bda338732d87a7a0c5b0ae>
{
  ScreenView *const __this;
};

SceneStack::isScreenReplaceable::__l8::<lambda_42a230a3bda507ad00601db397fdd7c6>

struct __cppobj SceneStack::isScreenReplaceable::__l8::<lambda_42a230a3bda507ad00601db397fdd7c6>
{
  bool *canReplace;
};

SceneFactory::createActiveDirectoryModal::__l2::<lambda_9f02b271ede7732ee4ddc2d56da6dc4c>

struct __cppobj SceneFactory::createActiveDirectoryModal::__l2::<lambda_9f02b271ede7732ee4ddc2d56da6dc4c>
{
};

SceneFactory::createActiveDirectoryModal::__l2::<lambda_9f02b271ede7732ee4ddc2d56da6dc4c>::()::__l2::StrAccessor

struct __cppobj SceneFactory::createActiveDirectoryModal::__l2::<lambda_9f02b271ede7732ee4ddc2d56da6dc4c>::()::__l2::StrAccessor
{
};

SceneFactory::createActiveDirectoryAuthenticationScreen::__l2::<lambda_adcf6bd9062ebad447b2428204664251>

struct __cppobj SceneFactory::createActiveDirectoryAuthenticationScreen::__l2::<lambda_adcf6bd9062ebad447b2428204664251>
{
};

SceneFactory::createActiveDirectoryAuthenticationScreen::__l2::<lambda_adcf6bd9062ebad447b2428204664251>::()::__l2::StrAccessor

struct __cppobj SceneFactory::createActiveDirectoryAuthenticationScreen::__l2::<lambda_adcf6bd9062ebad447b2428204664251>::()::__l2::StrAccessor
{
};

SkinnedMesh::draw::__l2::<lambda_d8b94b46a694729780a8881de11c5537>

struct __cppobj SkinnedMesh::draw::__l2::<lambda_d8b94b46a694729780a8881de11c5537>
{
};

ScriptEngineWithContext<ScriptClientContext>::createEntity::__l2::<lambda_e35908d952b2d50bdbc7c021fe0b8d2e>

struct __cppobj ScriptEngineWithContext<ScriptClientContext>::createEntity::__l2::<lambda_e35908d952b2d50bdbc7c021fe0b8d2e>
{
  ScriptEngineWithContext<ScriptClientContext> *const __this;
  ScriptApi::ScriptObjectHandle *entityHandle;
  const std::string *templateName;
  const ScriptApi::ScriptVersionInfo *info;
};

Social::MultiplayerEDU::_joinGame::__l2::<lambda_c0daf9fcddb69c3e6164bbe064128aa0>

struct __cppobj Social::MultiplayerEDU::_joinGame::__l2::<lambda_c0daf9fcddb69c3e6164bbe064128aa0>
{
  Social::MultiplayerEDU *const __this;
};

Social::UserManager::removeClient::__l4::<lambda_8bffe92b839cdd3926f9f46b2b9196ba>

struct __cppobj Social::UserManager::removeClient::__l4::<lambda_8bffe92b839cdd3926f9f46b2b9196ba>
{
  std::shared_ptr<IClientInstance> ci;
};

Social::XboxLiveUser::isUserOnFriendList::__l2::<lambda_938f7b7cbdf1e4157d9f58c7ba6ac2ab>

struct __cppobj Social::XboxLiveUser::isUserOnFriendList::__l2::<lambda_938f7b7cbdf1e4157d9f58c7ba6ac2ab>
{
  const std::string xuid;
};

SoundEngine::_isNewMusicQueued::__l9::<lambda_6058b0ebf9d487346dfc78cfeeed8549>

struct __cppobj SoundEngine::_isNewMusicQueued::__l9::<lambda_6058b0ebf9d487346dfc78cfeeed8549>
{
  const Core::Path currentMusicItemName;
};

StoreCatalogRepository::fetchRealmsCoinOffers::__l2::<lambda_4414f3671be2def991047236b7ca18b5>::()::__l9::<lambda_5b34530ea6fe3708d069590feac9be75>

struct __cppobj StoreCatalogRepository::fetchRealmsCoinOffers::__l2::<lambda_4414f3671be2def991047236b7ca18b5>::()::__l9::<lambda_5b34530ea6fe3708d069590feac9be75>
{
  const std::string sku;
};

ServerPlayerBlockUseHandler::onBeforeMovementSimulation::__l2::<lambda_c316d9e687abcf3d528563fc19364bf8>

struct __cppobj ServerPlayerBlockUseHandler::onBeforeMovementSimulation::__l2::<lambda_c316d9e687abcf3d528563fc19364bf8>
{
  std::unique_ptr<ItemStackRequestData> *itemStackRequest;
};

ServerNetworkHandler::engineDownloadingResponseHelper::__l18::<lambda_00b0622c98e5187c8a83036a771f6e2e>

struct __cppobj ServerNetworkHandler::engineDownloadingResponseHelper::__l18::<lambda_00b0622c98e5187c8a83036a771f6e2e>
{
  const std::string *packIdStr;
};

ServerNetworkHandler::engineDownloadingResponseHelper::__l2::<lambda_c2403a719f261949b9930649a7bed9eb>::()::__l12::<lambda_9d5d32d71ee2269e33a959b1a38ae504>

struct __cppobj ServerNetworkHandler::engineDownloadingResponseHelper::__l2::<lambda_c2403a719f261949b9930649a7bed9eb>::()::__l12::<lambda_9d5d32d71ee2269e33a959b1a38ae504>
{
  const std::string *packIdStr;
};

ServerNetworkHandler::_onClientAuthenticated::__l2::<lambda_5bf7633c5afa8e06c799ce108426113a>

struct __cppobj ServerNetworkHandler::_onClientAuthenticated::__l2::<lambda_5bf7633c5afa8e06c799ce108426113a>
{
  ServerNetworkHandler *const __this;
};

ServerNetworkHandler::_getActiveAndInProgressPlayerCount::__l2::<lambda_831ea39846ba7d8b403f58c6fc8cdb87>

struct __cppobj ServerNetworkHandler::_getActiveAndInProgressPlayerCount::__l2::<lambda_831ea39846ba7d8b403f58c6fc8cdb87>
{
  const ServerNetworkHandler *const __this;
  mce::UUID *excludePlayer;
  int *numPlayers;
};

ServerNetworkHandler::engineDownloadingResponseHelper::__l2::<lambda_c2403a719f261949b9930649a7bed9eb>

struct __cppobj ServerNetworkHandler::engineDownloadingResponseHelper::__l2::<lambda_c2403a719f261949b9930649a7bed9eb>
{
  ServerNetworkHandler *const __this;
  const NetworkIdentifier *source;
  std::set<std::string> *downloading;
};

ScriptInventoryContainerComponent::hasComponent::__l2::<lambda_cbfd00fac5e89c48dc5b9818cc515444>::()::__l2::Literal

struct __cppobj ScriptInventoryContainerComponent::hasComponent::__l2::<lambda_cbfd00fac5e89c48dc5b9818cc515444>::()::__l2::Literal
{
};

ScriptInventoryContainerComponent::hasComponent::__l2::<lambda_cbfd00fac5e89c48dc5b9818cc515444>

struct __cppobj ScriptInventoryContainerComponent::hasComponent::__l2::<lambda_cbfd00fac5e89c48dc5b9818cc515444>
{
};

ServerInstance::suspend::__l5::<lambda_e2bf1bc6a494a9ac2de26852ce0ed296>::()::__l2::<lambda_dc1051d76d2d8e5ed26ddec900f12518>

struct __cppobj ServerInstance::suspend::__l5::<lambda_e2bf1bc6a494a9ac2de26852ce0ed296>::()::__l2::<lambda_dc1051d76d2d8e5ed26ddec900f12518>
{
  ServerInstance *const __this;
};

ServerPlayer::recoverR5LostInventoryAndXP::__l2::<lambda_07493d55d977c843ffdb606ac04a2f9f>

struct __cppobj ServerPlayer::recoverR5LostInventoryAndXP::__l2::<lambda_07493d55d977c843ffdb606ac04a2f9f>
{
  std::vector<BlockPos> chestPositions;
};

ServerInstance::initializeServer::__l49::<lambda_3a7cf20926733d23785fdc1bad5b8ff2>

struct __cppobj ServerInstance::initializeServer::__l49::<lambda_3a7cf20926733d23785fdc1bad5b8ff2>
{
  std::unordered_map<PackIdVersion,std::string> *packIdToContentKey;
  ResourcePackRepository *resourcePackRepository;
};

Squid::spawnInkParticles::__l2::<lambda_20ed655d1fdb0c0dc03fd2267680f974>::()::__l2::Literal

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_20ed655d1fdb0c0dc03fd2267680f974>::()::__l2::Literal
{
};

Squid::spawnInkParticles::__l2::<lambda_81d88c366bffed15d10e67d2c2427073>::()::__l2::Literal

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_81d88c366bffed15d10e67d2c2427073>::()::__l2::Literal
{
};

Squid::spawnInkParticles::__l2::<lambda_f866df35e06d0821240572926370310a>::()::__l2::Literal

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_f866df35e06d0821240572926370310a>::()::__l2::Literal
{
};

Squid::spawnInkParticles::__l2::<lambda_a6ccd1b2e2a58943ed7603f95ec71137>::()::__l2::Literal

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_a6ccd1b2e2a58943ed7603f95ec71137>::()::__l2::Literal
{
};

Squid::spawnInkParticles::__l2::<lambda_745c8c632ec8667527937f4fd921d65d>::()::__l2::Literal

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_745c8c632ec8667527937f4fd921d65d>::()::__l2::Literal
{
};

Squid::aiStep::__l38::<lambda_7c935aff097e3f4f0757a5f398e28e3b>::()::__l2::Literal

struct __cppobj Squid::aiStep::__l38::<lambda_7c935aff097e3f4f0757a5f398e28e3b>::()::__l2::Literal
{
};

Squid::spawnInkParticles::__l9::<lambda_dd17807679feb6004cad8b221e669871>::()::__l2::Literal

struct __cppobj Squid::spawnInkParticles::__l9::<lambda_dd17807679feb6004cad8b221e669871>::()::__l2::Literal
{
};

Squid::updateEntitySpecificMolangVariables::__l2::<lambda_54ff11a541b599c5179e16b1d9d14457>::()::__l2::Literal

struct __cppobj Squid::updateEntitySpecificMolangVariables::__l2::<lambda_54ff11a541b599c5179e16b1d9d14457>::()::__l2::Literal
{
};

Squid::spawnInkParticles::__l2::<lambda_20ed655d1fdb0c0dc03fd2267680f974>

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_20ed655d1fdb0c0dc03fd2267680f974>
{
};

Squid::updateEntitySpecificMolangVariables::__l2::<lambda_54ff11a541b599c5179e16b1d9d14457>

struct __cppobj Squid::updateEntitySpecificMolangVariables::__l2::<lambda_54ff11a541b599c5179e16b1d9d14457>
{
};

Squid::spawnInkParticles::__l2::<lambda_745c8c632ec8667527937f4fd921d65d>

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_745c8c632ec8667527937f4fd921d65d>
{
};

Squid::aiStep::__l38::<lambda_7c935aff097e3f4f0757a5f398e28e3b>

struct __cppobj Squid::aiStep::__l38::<lambda_7c935aff097e3f4f0757a5f398e28e3b>
{
};

Squid::spawnInkParticles::__l2::<lambda_81d88c366bffed15d10e67d2c2427073>

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_81d88c366bffed15d10e67d2c2427073>
{
};

Squid::spawnInkParticles::__l2::<lambda_a6ccd1b2e2a58943ed7603f95ec71137>

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_a6ccd1b2e2a58943ed7603f95ec71137>
{
};

Squid::spawnInkParticles::__l9::<lambda_dd17807679feb6004cad8b221e669871>

struct __cppobj Squid::spawnInkParticles::__l9::<lambda_dd17807679feb6004cad8b221e669871>
{
};

Squid::spawnInkParticles::__l2::<lambda_f866df35e06d0821240572926370310a>

struct __cppobj Squid::spawnInkParticles::__l2::<lambda_f866df35e06d0821240572926370310a>
{
};

SubtreeDefinition::load::__l2::<lambda_812a7dd9662048876f94e3c602f5749a>

struct __cppobj SubtreeDefinition::load::__l2::<lambda_812a7dd9662048876f94e3c602f5749a>
{
  SubtreeDefinition *const __this;
};

Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_7ee7d0e96e7f086bf09398b468cf2075>::()::__l2::Literal

struct __cppobj Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_7ee7d0e96e7f086bf09398b468cf2075>::()::__l2::Literal
{
};

Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_acd0cdf20e3b5cde0d6a58a55011ea1d>::()::__l2::Literal

struct __cppobj Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_acd0cdf20e3b5cde0d6a58a55011ea1d>::()::__l2::Literal
{
};

Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_bcd9dfb7d43d7c010ff946aba3e014f2>::()::__l2::Literal

struct __cppobj Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_bcd9dfb7d43d7c010ff946aba3e014f2>::()::__l2::Literal
{
};

Silverfish::spawnAnim::__l2::<lambda_19e1d0aacea10af139bf394457913d53>::()::__l2::Literal

struct __cppobj Silverfish::spawnAnim::__l2::<lambda_19e1d0aacea10af139bf394457913d53>::()::__l2::Literal
{
};

Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_acae4de5d24cbf0518c8cbf9196c47aa>::()::__l2::Literal

struct __cppobj Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_acae4de5d24cbf0518c8cbf9196c47aa>::()::__l2::Literal
{
};

Silverfish::spawnAnim::__l2::<lambda_19e1d0aacea10af139bf394457913d53>

struct __cppobj Silverfish::spawnAnim::__l2::<lambda_19e1d0aacea10af139bf394457913d53>
{
};

Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_7ee7d0e96e7f086bf09398b468cf2075>

struct __cppobj Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_7ee7d0e96e7f086bf09398b468cf2075>
{
};

Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_acae4de5d24cbf0518c8cbf9196c47aa>

struct __cppobj Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_acae4de5d24cbf0518c8cbf9196c47aa>
{
};

Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_acd0cdf20e3b5cde0d6a58a55011ea1d>

struct __cppobj Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_acd0cdf20e3b5cde0d6a58a55011ea1d>
{
};

Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_bcd9dfb7d43d7c010ff946aba3e014f2>

struct __cppobj Shulker::updateEntitySpecificMolangVariables::__l2::<lambda_bcd9dfb7d43d7c010ff946aba3e014f2>
{
};

SpongeBlock::_spawnAbsorbParticles::__l4::<lambda_281430efca4f4a8de2a9d661daf56df2>::()::__l2::Literal

struct __cppobj SpongeBlock::_spawnAbsorbParticles::__l4::<lambda_281430efca4f4a8de2a9d661daf56df2>::()::__l2::Literal
{
};

SpongeBlock::_spawnAbsorbParticles::__l4::<lambda_281430efca4f4a8de2a9d661daf56df2>

struct __cppobj SpongeBlock::_spawnAbsorbParticles::__l4::<lambda_281430efca4f4a8de2a9d661daf56df2>
{
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_b89d7faeb8625652467465f4053f1a1e>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_b89d7faeb8625652467465f4053f1a1e>
{
  std::array<unsigned __int64,2> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_ee02d42ed08427f9fb42002a8b8ca57d>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_ee02d42ed08427f9fb42002a8b8ca57d>
{
  std::array<unsigned __int64,2> *remappingLookup;
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_58da501a9e5a53b0697e720a47037e87>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_58da501a9e5a53b0697e720a47037e87>
{
  std::array<unsigned __int64,2> *remappingLookup;
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_659fa460fcd8c91f9c29efb516ca29a4>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_659fa460fcd8c91f9c29efb516ca29a4>
{
  std::array<unsigned __int64,2> *remappingLookup;
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_bfaabf8c679a87b6e2d83295f0010d23>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_bfaabf8c679a87b6e2d83295f0010d23>
{
  std::array<unsigned __int64,2> *remappingLookup;
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_f8315e4b756b9df6ad9782338da705eb>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_f8315e4b756b9df6ad9782338da705eb>
{
  std::array<unsigned __int64,2> *remappingLookup;
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_b6e2926387827d0322d995e610a39062>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_b6e2926387827d0322d995e610a39062>
{
  std::array<unsigned __int64,2> *remappingLookup;
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_79653376107e589b67701292641889fb>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_79653376107e589b67701292641889fb>
{
  std::array<unsigned __int64,2> *remappingLookup;
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_41ef2a1cf9e6be72ad5379c22f5e274a>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_41ef2a1cf9e6be72ad5379c22f5e274a>
{
  std::array<unsigned __int64,4> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_f6550f24920c305d2a3228c1caad78b8>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_f6550f24920c305d2a3228c1caad78b8>
{
  std::array<unsigned __int64,4> *remappingLookup;
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_bc44f7e86affe751fd9c46eb71543178>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_bc44f7e86affe751fd9c46eb71543178>
{
  std::array<unsigned __int64,4> *remappingLookup;
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_469bd9e3b15d63a3bec8b65106f8890c>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_469bd9e3b15d63a3bec8b65106f8890c>
{
  std::array<unsigned __int64,4> *remappingLookup;
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_2c377cf4a0b195dfab8182eb8ff7fe0f>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_2c377cf4a0b195dfab8182eb8ff7fe0f>
{
  std::array<unsigned __int64,4> *remappingLookup;
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_bbbc0f4fafb53fc32059227f6c0c450f>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_bbbc0f4fafb53fc32059227f6c0c450f>
{
  std::array<unsigned __int64,4> *remappingLookup;
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_3950691e075ab91cd491b17c4310546e>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_3950691e075ab91cd491b17c4310546e>
{
  std::array<unsigned __int64,4> *remappingLookup;
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_83d310390567ffecea966b4919d30ac8>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_83d310390567ffecea966b4919d30ac8>
{
  std::array<unsigned __int64,4> *remappingLookup;
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_d7d9298a0aebfa663a195f3482260e81>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_d7d9298a0aebfa663a195f3482260e81>
{
  std::array<unsigned __int64,8> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_197910b15336c6c57fb079552212abf9>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_197910b15336c6c57fb079552212abf9>
{
  std::array<unsigned __int64,8> *remappingLookup;
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_8f4d5d31dc10279ae8a6f79bc1288959>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_8f4d5d31dc10279ae8a6f79bc1288959>
{
  std::array<unsigned __int64,8> *remappingLookup;
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_6cac658f9939f9fdcf21c2bb28998155>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_6cac658f9939f9fdcf21c2bb28998155>
{
  std::array<unsigned __int64,8> *remappingLookup;
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_29e923ba2bd56312b230cf095fc262ab>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_29e923ba2bd56312b230cf095fc262ab>
{
  std::array<unsigned __int64,8> *remappingLookup;
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_8ed02beb6fa123e2e4b230d4b7fed29e>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_8ed02beb6fa123e2e4b230d4b7fed29e>
{
  std::array<unsigned __int64,8> *remappingLookup;
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_4b93ab98a1c1995005831a07db31e259>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_4b93ab98a1c1995005831a07db31e259>
{
  std::array<unsigned __int64,8> *remappingLookup;
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_a742bfdf2437d491e99310db58d7daf2>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_a742bfdf2437d491e99310db58d7daf2>
{
  std::array<unsigned __int64,8> *remappingLookup;
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_cd9c28223f1f7e791d8b4829dc4db1a8>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_cd9c28223f1f7e791d8b4829dc4db1a8>
{
  std::array<unsigned __int64,16> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_82094842f7d520b5264a46a912e7b041>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_82094842f7d520b5264a46a912e7b041>
{
  std::array<unsigned __int64,16> *remappingLookup;
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_9a10c8d6d7cc96e7b05d64277e151ddc>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_9a10c8d6d7cc96e7b05d64277e151ddc>
{
  std::array<unsigned __int64,16> *remappingLookup;
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_9a59a157a43846344d974fc798480d36>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_9a59a157a43846344d974fc798480d36>
{
  std::array<unsigned __int64,16> *remappingLookup;
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_9e1a0dcb27e98dcb2b0dd0c738266d83>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_9e1a0dcb27e98dcb2b0dd0c738266d83>
{
  std::array<unsigned __int64,16> *remappingLookup;
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_19fb2b0eda159d1884bb0c9ded0eccd8>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_19fb2b0eda159d1884bb0c9ded0eccd8>
{
  std::array<unsigned __int64,16> *remappingLookup;
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_b99f6b3392fe60ef2f5160864d6377b0>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_b99f6b3392fe60ef2f5160864d6377b0>
{
  std::array<unsigned __int64,16> *remappingLookup;
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_9d4dc4f6cb6703c61b6dfd39d3a81637>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_9d4dc4f6cb6703c61b6dfd39d3a81637>
{
  std::array<unsigned __int64,16> *remappingLookup;
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_e8bf3bc4d2c99c57826d07951044b5b5>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_e8bf3bc4d2c99c57826d07951044b5b5>
{
  std::array<unsigned __int64,256> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_9c3c32c12509b945041a07efec1f4018>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_9c3c32c12509b945041a07efec1f4018>
{
  std::array<unsigned __int64,256> *remappingLookup;
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_30ac5ed33c057b47ad3e061255bc9f85>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_30ac5ed33c057b47ad3e061255bc9f85>
{
  std::array<unsigned __int64,256> *remappingLookup;
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_7a0286341374ba7ace6e9c1673e7fcf0>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_7a0286341374ba7ace6e9c1673e7fcf0>
{
  std::array<unsigned __int64,256> *remappingLookup;
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_d8c3aa28f4250d79cb1f214ff0524749>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_d8c3aa28f4250d79cb1f214ff0524749>
{
  std::array<unsigned __int64,256> *remappingLookup;
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_c91dd27f63e11c7332a1b13efc647b2a>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_c91dd27f63e11c7332a1b13efc647b2a>
{
  std::array<unsigned __int64,256> *remappingLookup;
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_7ed2c87cb0677ad293c75ec93c239094>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_7ed2c87cb0677ad293c75ec93c239094>
{
  std::array<unsigned __int64,256> *remappingLookup;
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_77cb8d6a030c374aa1dc15ade6754a87>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_77cb8d6a030c374aa1dc15ade6754a87>
{
  std::array<unsigned __int64,256> *remappingLookup;
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_5c54a6d5e82ef8fe4e108535597a07a5>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_5c54a6d5e82ef8fe4e108535597a07a5>
{
  std::array<unsigned __int64,4096> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_d529bd2d858807c48987aaa1084a2b8d>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_d529bd2d858807c48987aaa1084a2b8d>
{
  std::array<unsigned __int64,4096> *remappingLookup;
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_578a91390099f186d7171712656310be>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_578a91390099f186d7171712656310be>
{
  std::array<unsigned __int64,4096> *remappingLookup;
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_1ed035df95b6b5b1bbdacd8771e68b80>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_1ed035df95b6b5b1bbdacd8771e68b80>
{
  std::array<unsigned __int64,4096> *remappingLookup;
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_8470c3d3d53641c5f515fa0a50f7d203>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_8470c3d3d53641c5f515fa0a50f7d203>
{
  std::array<unsigned __int64,4096> *remappingLookup;
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_e64f1a17e18be658772b1736538eadb6>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_e64f1a17e18be658772b1736538eadb6>
{
  std::array<unsigned __int64,4096> *remappingLookup;
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_00be663ed5f61e98eadb6cdeb28378f4>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_00be663ed5f61e98eadb6cdeb28378f4>
{
  std::array<unsigned __int64,4096> *remappingLookup;
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_c31f78ab0fc73eaf1e1744a301d0ad5f>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_c31f78ab0fc73eaf1e1744a301d0ad5f>
{
  std::array<unsigned __int64,4096> *remappingLookup;
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_961742dd9bc1d976bf071baf7b6a837b>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_961742dd9bc1d976bf071baf7b6a837b>
{
  std::array<unsigned __int64,32> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_835c95f7d954b44a1692ec9f4c720c21>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_835c95f7d954b44a1692ec9f4c720c21>
{
  std::array<unsigned __int64,32> *remappingLookup;
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_7a387bd6d2d2ba4bd42bcc8d34cd3cd7>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_7a387bd6d2d2ba4bd42bcc8d34cd3cd7>
{
  std::array<unsigned __int64,32> *remappingLookup;
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_016baf4e196323c8538fd94c98b531d8>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_016baf4e196323c8538fd94c98b531d8>
{
  std::array<unsigned __int64,32> *remappingLookup;
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_e1beab7cca7d279280ff45eb3be3974f>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_e1beab7cca7d279280ff45eb3be3974f>
{
  std::array<unsigned __int64,32> *remappingLookup;
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_922346ceb579a190cf9385daa338d6c0>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_922346ceb579a190cf9385daa338d6c0>
{
  std::array<unsigned __int64,32> *remappingLookup;
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_36b90fddf1b151e4e3615e85857d0647>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_36b90fddf1b151e4e3615e85857d0647>
{
  std::array<unsigned __int64,32> *remappingLookup;
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_8cb60d75dc4e5d8b6cd616474e0a20f3>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_8cb60d75dc4e5d8b6cd616474e0a20f3>
{
  std::array<unsigned __int64,32> *remappingLookup;
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_8fa1d2d0560a314c97ef3959fc62aa6e>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_8fa1d2d0560a314c97ef3959fc62aa6e>
{
  std::array<unsigned __int64,64> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_58a2dd194639f141c5dec720842771d5>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_58a2dd194639f141c5dec720842771d5>
{
  std::array<unsigned __int64,64> *remappingLookup;
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_186f12fb5c9ea95857c941f086043dfd>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_186f12fb5c9ea95857c941f086043dfd>
{
  std::array<unsigned __int64,64> *remappingLookup;
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_ffb12327d2445fa1d089d3cd84baf000>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_ffb12327d2445fa1d089d3cd84baf000>
{
  std::array<unsigned __int64,64> *remappingLookup;
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_00de30484d20d3df2ccba38bd470dad4>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_00de30484d20d3df2ccba38bd470dad4>
{
  std::array<unsigned __int64,64> *remappingLookup;
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_b337c4c891a1361a908e2abb77fa22e4>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_b337c4c891a1361a908e2abb77fa22e4>
{
  std::array<unsigned __int64,64> *remappingLookup;
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_2ecb361f8582be43669bd1b87db23296>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_2ecb361f8582be43669bd1b87db23296>
{
  std::array<unsigned __int64,64> *remappingLookup;
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_07f6beca060ecad8ce0a9287d8b20e62>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_07f6beca060ecad8ce0a9287d8b20e62>
{
  std::array<unsigned __int64,64> *remappingLookup;
};

SubChunkBlockStoragePaletted<2,2>::fetchBlocksInBox::__l2::<lambda_05dcea0d077ab08977860bf1536271dc>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::fetchBlocksInBox::__l2::<lambda_05dcea0d077ab08977860bf1536271dc>
{
  const BoundingBox *box;
};

SubChunkBlockStoragePaletted<5,5>::fetchBlocksInCylinder::__l2::<lambda_2225f5dd488587be97d5ef16dbb05a4e>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::fetchBlocksInCylinder::__l2::<lambda_2225f5dd488587be97d5ef16dbb05a4e>
{
  unsigned int height;
  unsigned int radius;
  const BlockPos *pos;
};

SubChunkBlockStoragePaletted<8,8>::fetchBlocksInCylinder::__l2::<lambda_2f8920f8aed8669ce026a439bb206b81>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::fetchBlocksInCylinder::__l2::<lambda_2f8920f8aed8669ce026a439bb206b81>
{
  unsigned int height;
  unsigned int radius;
  const BlockPos *pos;
};

SubChunkBlockStoragePaletted<4,4>::fetchBlocksInCylinder::__l2::<lambda_31ae1f2113d30483dfa86a8979a4b0c4>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::fetchBlocksInCylinder::__l2::<lambda_31ae1f2113d30483dfa86a8979a4b0c4>
{
  unsigned int height;
  unsigned int radius;
  const BlockPos *pos;
};

SubChunkBlockStoragePaletted<3,3>::fetchBlocksInBox::__l2::<lambda_333c91ec917de2d00c7d7b20be94f138>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::fetchBlocksInBox::__l2::<lambda_333c91ec917de2d00c7d7b20be94f138>
{
  const BoundingBox *box;
};

SubChunkBlockStoragePaletted<1,1>::fetchBlocksInBox::__l2::<lambda_3a25f8be0adce3e4613c2792bb15ad32>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::fetchBlocksInBox::__l2::<lambda_3a25f8be0adce3e4613c2792bb15ad32>
{
  const BoundingBox *box;
};

SubChunkBlockStoragePaletted<4,4>::fetchBlocksInBox::__l2::<lambda_6805beeeeb20926306bc087a374beb00>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::fetchBlocksInBox::__l2::<lambda_6805beeeeb20926306bc087a374beb00>
{
  const BoundingBox *box;
};

SubChunkBlockStoragePaletted<3,3>::fetchBlocksInCylinder::__l2::<lambda_69eb90666f66735dbbd3c93a3c693a3d>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::fetchBlocksInCylinder::__l2::<lambda_69eb90666f66735dbbd3c93a3c693a3d>
{
  unsigned int height;
  unsigned int radius;
  const BlockPos *pos;
};

SubChunkBlockStoragePaletted<1,1>::fetchBlocksInCylinder::__l2::<lambda_6eff12cf755cbc8df5ad19484681e643>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::fetchBlocksInCylinder::__l2::<lambda_6eff12cf755cbc8df5ad19484681e643>
{
  unsigned int height;
  unsigned int radius;
  const BlockPos *pos;
};

SubChunkBlockStoragePaletted<16,16>::fetchBlocksInCylinder::__l2::<lambda_7ad7ae9e0b04fad7956ba5c2462033f8>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::fetchBlocksInCylinder::__l2::<lambda_7ad7ae9e0b04fad7956ba5c2462033f8>
{
  unsigned int height;
  unsigned int radius;
  const BlockPos *pos;
};

SubChunkBlockStoragePaletted<16,16>::fetchBlocksInBox::__l2::<lambda_81f82229aefcc027330dfa10aa9c846d>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::fetchBlocksInBox::__l2::<lambda_81f82229aefcc027330dfa10aa9c846d>
{
  const BoundingBox *box;
};

SubChunkBlockStoragePaletted<6,6>::fetchBlocksInCylinder::__l2::<lambda_8505f348207d8ed882a967b263f00729>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::fetchBlocksInCylinder::__l2::<lambda_8505f348207d8ed882a967b263f00729>
{
  unsigned int height;
  unsigned int radius;
  const BlockPos *pos;
};

SubChunkBlockStoragePaletted<2,2>::fetchBlocksInCylinder::__l2::<lambda_92f021db926b66e17c3d1841e8d27176>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::fetchBlocksInCylinder::__l2::<lambda_92f021db926b66e17c3d1841e8d27176>
{
  unsigned int height;
  unsigned int radius;
  const BlockPos *pos;
};

SubChunkBlockStoragePaletted<6,6>::fetchBlocksInBox::__l2::<lambda_997cfac59e34b9c498561474fd5a53aa>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::fetchBlocksInBox::__l2::<lambda_997cfac59e34b9c498561474fd5a53aa>
{
  const BoundingBox *box;
};

SubChunkBlockStoragePaletted<5,5>::fetchBlocksInBox::__l2::<lambda_edcd7c6147545643dd4f557b53945643>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::fetchBlocksInBox::__l2::<lambda_edcd7c6147545643dd4f557b53945643>
{
  const BoundingBox *box;
};

SubChunkBlockStoragePaletted<8,8>::fetchBlocksInBox::__l2::<lambda_f43d19be392b01ec54de03992e19bbb7>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::fetchBlocksInBox::__l2::<lambda_f43d19be392b01ec54de03992e19bbb7>
{
  const BoundingBox *box;
};

SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_3d3775961188f5d75cc9165de79473f8>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::{ctor}::__l5::<lambda_3d3775961188f5d75cc9165de79473f8>
{
};

SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_544678e6bb1251d1e1246e2f40073bdf>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::{ctor}::__l5::<lambda_544678e6bb1251d1e1246e2f40073bdf>
{
};

SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_783ffbd839a4ef6bf7f3e7e71a917099>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::{ctor}::__l5::<lambda_783ffbd839a4ef6bf7f3e7e71a917099>
{
};

SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_7f372ce8f01d8e7eca85b0df7b158601>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::{ctor}::__l5::<lambda_7f372ce8f01d8e7eca85b0df7b158601>
{
};

SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_9d948e124c24db4d860e66e0195e2b1b>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::{ctor}::__l5::<lambda_9d948e124c24db4d860e66e0195e2b1b>
{
};

SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_b4ac387c3660a6cd85cfd19de4a596e5>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::{ctor}::__l5::<lambda_b4ac387c3660a6cd85cfd19de4a596e5>
{
};

SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_bb5dbc2c16fccebb88d3f7ca9022c57c>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::{ctor}::__l5::<lambda_bb5dbc2c16fccebb88d3f7ca9022c57c>
{
};

SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_f1843f9aa6d0f0bab8652ab8fb95c2ac>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::{ctor}::__l5::<lambda_f1843f9aa6d0f0bab8652ab8fb95c2ac>
{
};

SubChunkBlockStoragePaletted<4,4>::_zeroIndicesGreaterEqualThan::__l2::<lambda_09a7b7eccde96f168aefdcf4510b1048>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::_zeroIndicesGreaterEqualThan::__l2::<lambda_09a7b7eccde96f168aefdcf4510b1048>
{
  unsigned __int16 *max;
  std::vector<unsigned short> *outOfBoundSlots;
  unsigned __int64 *idx;
};

SubChunkBlockStoragePaletted<8,8>::findUsedIndices::__l2::<lambda_17bedaa24e4c7f9ff6efe58e06d20e2c>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::findUsedIndices::__l2::<lambda_17bedaa24e4c7f9ff6efe58e06d20e2c>
{
  std::bitset<256> *existing;
};

SubChunkBlockStoragePaletted<2,2>::findUsedIndices::__l2::<lambda_2ed1e938e204f4521098f089a261134c>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::findUsedIndices::__l2::<lambda_2ed1e938e204f4521098f089a261134c>
{
  std::bitset<4> *existing;
};

SubChunkBlockStoragePaletted<16,16>::findUsedIndices::__l2::<lambda_42453c35bc07ae9da0d838fd6046c080>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::findUsedIndices::__l2::<lambda_42453c35bc07ae9da0d838fd6046c080>
{
  std::bitset<4096> *existing;
};

SubChunkBlockStoragePaletted<3,3>::findUsedIndices::__l2::<lambda_4c55d5191fba51a33256aebbbc639402>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::findUsedIndices::__l2::<lambda_4c55d5191fba51a33256aebbbc639402>
{
  std::bitset<8> *existing;
};

SubChunkBlockStoragePaletted<6,6>::findUsedIndices::__l2::<lambda_5326846d6b6a4a52eef1e117e9eaadd5>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::findUsedIndices::__l2::<lambda_5326846d6b6a4a52eef1e117e9eaadd5>
{
  std::bitset<64> *existing;
};

SubChunkBlockStoragePaletted<16,16>::_zeroIndicesGreaterEqualThan::__l2::<lambda_5b5744cc523e02cf0d9ddc9cfb78437c>

struct __cppobj SubChunkBlockStoragePaletted<16,16>::_zeroIndicesGreaterEqualThan::__l2::<lambda_5b5744cc523e02cf0d9ddc9cfb78437c>
{
  unsigned __int16 *max;
  std::vector<unsigned short> *outOfBoundSlots;
  unsigned __int64 *idx;
};

SubChunkBlockStoragePaletted<8,8>::_zeroIndicesGreaterEqualThan::__l2::<lambda_5c6bcf649dce0f48c2923e314a547cad>

struct __cppobj SubChunkBlockStoragePaletted<8,8>::_zeroIndicesGreaterEqualThan::__l2::<lambda_5c6bcf649dce0f48c2923e314a547cad>
{
  unsigned __int16 *max;
  std::vector<unsigned short> *outOfBoundSlots;
  unsigned __int64 *idx;
};

SubChunkBlockStoragePaletted<6,6>::_zeroIndicesGreaterEqualThan::__l2::<lambda_6d55ad4cff0dd4eabb29215fb608913f>

struct __cppobj SubChunkBlockStoragePaletted<6,6>::_zeroIndicesGreaterEqualThan::__l2::<lambda_6d55ad4cff0dd4eabb29215fb608913f>
{
  unsigned __int16 *max;
  std::vector<unsigned short> *outOfBoundSlots;
  unsigned __int64 *idx;
};

SubChunkBlockStoragePaletted<5,5>::_zeroIndicesGreaterEqualThan::__l2::<lambda_6e0dba5c30f06b0dff0181aec7e4af94>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::_zeroIndicesGreaterEqualThan::__l2::<lambda_6e0dba5c30f06b0dff0181aec7e4af94>
{
  unsigned __int16 *max;
  std::vector<unsigned short> *outOfBoundSlots;
  unsigned __int64 *idx;
};

SubChunkBlockStoragePaletted<1,1>::_zeroIndicesGreaterEqualThan::__l2::<lambda_77d2db69a28f5aff5902a2cc0216082c>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::_zeroIndicesGreaterEqualThan::__l2::<lambda_77d2db69a28f5aff5902a2cc0216082c>
{
  unsigned __int16 *max;
  std::vector<unsigned short> *outOfBoundSlots;
  unsigned __int64 *idx;
};

SubChunkBlockStoragePaletted<2,2>::_zeroIndicesGreaterEqualThan::__l2::<lambda_a77ad154162e45517fb3e1ee3c08a299>

struct __cppobj SubChunkBlockStoragePaletted<2,2>::_zeroIndicesGreaterEqualThan::__l2::<lambda_a77ad154162e45517fb3e1ee3c08a299>
{
  unsigned __int16 *max;
  std::vector<unsigned short> *outOfBoundSlots;
  unsigned __int64 *idx;
};

SubChunkBlockStoragePaletted<1,1>::findUsedIndices::__l2::<lambda_b3a5c9534f819a154621d0e7553c71e5>

struct __cppobj SubChunkBlockStoragePaletted<1,1>::findUsedIndices::__l2::<lambda_b3a5c9534f819a154621d0e7553c71e5>
{
  std::bitset<2> *existing;
};

SubChunkBlockStoragePaletted<4,4>::findUsedIndices::__l2::<lambda_cae54f3a68597e07934177246dc8cb8f>

struct __cppobj SubChunkBlockStoragePaletted<4,4>::findUsedIndices::__l2::<lambda_cae54f3a68597e07934177246dc8cb8f>
{
  std::bitset<16> *existing;
};

SubChunkBlockStoragePaletted<5,5>::findUsedIndices::__l2::<lambda_ccd75c963cecbc6c25cfcda0d301d8c1>

struct __cppobj SubChunkBlockStoragePaletted<5,5>::findUsedIndices::__l2::<lambda_ccd75c963cecbc6c25cfcda0d301d8c1>
{
  std::bitset<32> *existing;
};

SubChunkBlockStoragePaletted<3,3>::_zeroIndicesGreaterEqualThan::__l2::<lambda_fa644e9c48b0892bfb38e0eb2c45d93d>

struct __cppobj SubChunkBlockStoragePaletted<3,3>::_zeroIndicesGreaterEqualThan::__l2::<lambda_fa644e9c48b0892bfb38e0eb2c45d93d>
{
  unsigned __int16 *max;
  std::vector<unsigned short> *outOfBoundSlots;
  unsigned __int64 *idx;
};

SingleBlockFeature::_mayAttach::__l2::<lambda_2a6fcf79d125f18d56e9ee3d23280c35>

struct __cppobj SingleBlockFeature::_mayAttach::__l2::<lambda_2a6fcf79d125f18d56e9ee3d23280c35>
{
  const SingleBlockFeature *const __this;
};

SingleBlockFeature::_mayAttach::__l2::<lambda_e9c20ccf746f09597e99f3b2df791d8a>

struct __cppobj SingleBlockFeature::_mayAttach::__l2::<lambda_e9c20ccf746f09597e99f3b2df791d8a>
{
  const SingleBlockFeature *const __this;
};

StructureFeature::waitForFeatureBlueprints::__l2::<lambda_ae7082b559214a814fc226cfd7f32516>

struct __cppobj StructureFeature::waitForFeatureBlueprints::__l2::<lambda_ae7082b559214a814fc226cfd7f32516>
{
  StructureFeature *const __this;
};

StructureTemplate::_fillBlockInfo::__l2::<lambda_76eff4b48ee237c3d94a60cb41446511>

struct __cppobj StructureTemplate::_fillBlockInfo::__l2::<lambda_76eff4b48ee237c3d94a60cb41446511>
{
  const Block *voidBlock;
  std::map<Block const *,int> *blockToIndex;
  StructureBlockPalette *structureBlockPalette;
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_3a8b2a6fd80c4ca75449b56bc67f6f83>::()::__l2::Literal

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_3a8b2a6fd80c4ca75449b56bc67f6f83>::()::__l2::Literal
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_3f045b696bef04d0359231b688e14fa9>::()::__l2::Literal

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_3f045b696bef04d0359231b688e14fa9>::()::__l2::Literal
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_ed116ff0a398b7fd701b935508d112de>::()::__l2::Literal

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_ed116ff0a398b7fd701b935508d112de>::()::__l2::Literal
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_2e1116f26d303492bb04bdbca35dcc0c>::()::__l2::Literal

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_2e1116f26d303492bb04bdbca35dcc0c>::()::__l2::Literal
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_8c3a59de51eb0e6c7f11f2d764ffc7b3>::()::__l2::Literal

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_8c3a59de51eb0e6c7f11f2d764ffc7b3>::()::__l2::Literal
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_f7db91837f2565cf3fd818ae5745584f>::()::__l2::Literal

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_f7db91837f2565cf3fd818ae5745584f>::()::__l2::Literal
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_3f045b696bef04d0359231b688e14fa9>

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_3f045b696bef04d0359231b688e14fa9>
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_ed116ff0a398b7fd701b935508d112de>

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_ed116ff0a398b7fd701b935508d112de>
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_3a8b2a6fd80c4ca75449b56bc67f6f83>

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_3a8b2a6fd80c4ca75449b56bc67f6f83>
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_8c3a59de51eb0e6c7f11f2d764ffc7b3>

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_8c3a59de51eb0e6c7f11f2d764ffc7b3>
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_f7db91837f2565cf3fd818ae5745584f>

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_f7db91837f2565cf3fd818ae5745584f>
{
};

ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_2e1116f26d303492bb04bdbca35dcc0c>

struct __cppobj ScatterParamsMolangVariableIndices::{ctor}::__l2::<lambda_2e1116f26d303492bb04bdbca35dcc0c>
{
};

SnapshotEnv::createSnapshot::__l14::<lambda_633e2701bdb30152fc9f78453e74bb9a>

struct __cppobj SnapshotEnv::createSnapshot::__l14::<lambda_633e2701bdb30152fc9f78453e74bb9a>
{
};

ServerScoreboard::setDisplayObjective::__l8::<lambda_0747d8f05afc99c477135c4d36b10fe8>

struct __cppobj ServerScoreboard::setDisplayObjective::__l8::<lambda_0747d8f05afc99c477135c4d36b10fe8>
{
  const DisplayObjective **displayObjective;
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_c365b97a846660e6b3fccbcc72a4c37e>::()::__l2::Literal

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_c365b97a846660e6b3fccbcc72a4c37e>::()::__l2::Literal
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_c365b97a846660e6b3fccbcc72a4c37e>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_c365b97a846660e6b3fccbcc72a4c37e>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_1cd8d8773a9d60ac3364ae38a475281b>::()::__l2::Literal

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_1cd8d8773a9d60ac3364ae38a475281b>::()::__l2::Literal
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_1cd8d8773a9d60ac3364ae38a475281b>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_1cd8d8773a9d60ac3364ae38a475281b>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_4bfd93ca7d63de59fdffead62714b7fa>::()::__l2::Literal

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_4bfd93ca7d63de59fdffead62714b7fa>::()::__l2::Literal
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_4bfd93ca7d63de59fdffead62714b7fa>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_4bfd93ca7d63de59fdffead62714b7fa>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_db838ddadf31e2f802fde4f26a617c80>::()::__l2::Literal

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_db838ddadf31e2f802fde4f26a617c80>::()::__l2::Literal
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_db838ddadf31e2f802fde4f26a617c80>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_db838ddadf31e2f802fde4f26a617c80>
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_60b6d1bba4b02c0e8d10fc8be75855af>::()::__l2::Literal

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_60b6d1bba4b02c0e8d10fc8be75855af>::()::__l2::Literal
{
};

SimpleTreeCanopy::_buildSchema::__l2::<lambda_60b6d1bba4b02c0e8d10fc8be75855af>

struct __cppobj SimpleTreeCanopy::_buildSchema::__l2::<lambda_60b6d1bba4b02c0e8d10fc8be75855af>
{
};

SimpleTreeTrunk::_buildSchema::__l2::<lambda_defce208a08fa9ea383a3b955bef6273>::()::__l2::Literal

struct __cppobj SimpleTreeTrunk::_buildSchema::__l2::<lambda_defce208a08fa9ea383a3b955bef6273>::()::__l2::Literal
{
};

SimpleTreeTrunk::_buildSchema::__l2::<lambda_defce208a08fa9ea383a3b955bef6273>

struct __cppobj SimpleTreeTrunk::_buildSchema::__l2::<lambda_defce208a08fa9ea383a3b955bef6273>
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_9b631e13b9a6582f77c27a8d4c523d13>::()::__l2::Literal

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_9b631e13b9a6582f77c27a8d4c523d13>::()::__l2::Literal
{
};

SpruceTreeCanopy::_buildSchema::__l2::<lambda_9b631e13b9a6582f77c27a8d4c523d13>

struct __cppobj SpruceTreeCanopy::_buildSchema::__l2::<lambda_9b631e13b9a6582f77c27a8d4c523d13>
{
};

SHPortalRoom::postProcess::__l2::<lambda_ad4ab04a3053cfc72944c670238dd6f2>

struct __cppobj SHPortalRoom::postProcess::__l2::<lambda_ad4ab04a3053cfc72944c670238dd6f2>
{
  const Block **endPortalEye;
  const Block **endPortalNoEye;
};

SoundSystemFMOD::_addToSoundCache::__l5::<lambda_35441f677013214f2c5df3d329344406>

struct __cppobj SoundSystemFMOD::_addToSoundCache::__l5::<lambda_35441f677013214f2c5df3d329344406>
{
  SoundSystemFMOD *const __this;
  const Core::Path soundName;
};

SoundSystemFMOD::unloadAllExcept::__l20::<lambda_0e65d4d3526df21953afe127ce5ce183>

struct __cppobj SoundSystemFMOD::unloadAllExcept::__l20::<lambda_0e65d4d3526df21953afe127ce5ce183>
{
  const std::vector<Core::PathBuffer<std::string >> exceptions;
};

SoundSystemFMOD::fadeOut::__l2::<lambda_2b792a64d6c135a6d4a0beb3927c5059>

struct __cppobj SoundSystemFMOD::fadeOut::__l2::<lambda_2b792a64d6c135a6d4a0beb3927c5059>
{
  unsigned __int64 handle;
};

SerializerEnumMapping::lookup::__l2::<lambda_4bef74521c4bc00b8d630ed3c33fba83>

struct __cppobj SerializerEnumMapping::lookup::__l2::<lambda_4bef74521c4bc00b8d630ed3c33fba83>
{
};

sequence

struct __declspec(align(8)) sequence
{
  _object *it;
  int saw_StopIteration;
};

ScriptClientInstanceEventListener_vtbl

struct /*VFT*/ ScriptClientInstanceEventListener_vtbl
{
  void (__fastcall *~ClientInstanceEventListener)(ClientInstanceEventListener *this);
  EventResult (__fastcall *onClientInitializeStart)(ClientInstanceEventListener *this, ClientInstance *);
  EventResult (__fastcall *onClientInitializeEnd)(ClientInstanceEventListener *this, ClientInstance *);
  EventResult (__fastcall *onClientMinecraftInitialized)(ClientInstanceEventListener *this, ClientInstance *, Minecraft *);
  EventResult (__fastcall *onClientCreatedLevel)(ClientInstanceEventListener *this, ClientInstance *, Level *);
  EventResult (__fastcall *onClientUpdateStart)(ClientInstanceEventListener *this, ClientInstance *);
  EventResult (__fastcall *onClientUpdateEnd)(ClientInstanceEventListener *this, ClientInstance *);
  EventResult (__fastcall *onClientSuspend)(ClientInstanceEventListener *this, ClientInstance *);
  EventResult (__fastcall *onClientEnteredWorld)(ClientInstanceEventListener *this, ClientInstance *);
  EventResult (__fastcall *onStartLeaveGame)(ClientInstanceEventListener *this, ClientInstance *);
};

ServerLevel_vtbl

struct /*VFT*/ ServerLevel_vtbl
{
  void (__fastcall *~BlockSourceListener)(BlockSourceListener *this);
  void (__fastcall *onSourceCreated)(BlockSourceListener *this, BlockSource *);
  void (__fastcall *onSourceDestroyed)(BlockSourceListener *this, BlockSource *);
  void (__fastcall *onAreaChanged)(BlockSourceListener *this, BlockSource *, const BlockPos *, const BlockPos *);
  void (__fastcall *onBlockChanged)(BlockSourceListener *this, BlockSource *, const BlockPos *, unsigned int, const Block *, const Block *, int, const ActorBlockSyncMessage *);
  void (__fastcall *onBrightnessChanged)(BlockSourceListener *this, BlockSource *, const BlockPos *);
  void (__fastcall *onBlockEntityChanged)(BlockSourceListener *this, BlockSource *, BlockActor *);
  void (__fastcall *onBlockEntityAboutToBeRemoved)(BlockSourceListener *this, BlockSource *, std::shared_ptr<BlockActor>);
  void (__fastcall *onEntityChanged)(BlockSourceListener *this, BlockSource *, Actor *);
  void (__fastcall *onBlockEvent)(BlockSourceListener *this, BlockSource *, int, int, int, int, int);
  bool (__fastcall *initialize)(Level *this, const std::string *, const LevelSettings *, LevelData *, const std::string *);
  bool (__fastcall *postProcessResources)(Level *this);
  void (__fastcall *startLeaveGame)(Level *this);
  Actor *(__fastcall *addEntity)(Level *this, BlockSource *, std::unique_ptr<Actor>);
  Actor *(__fastcall *addGlobalEntity)(Level *this, BlockSource *, std::unique_ptr<Actor>);
  Actor *(__fastcall *addAutonomousEntity)(Level *this, BlockSource *, std::unique_ptr<Actor>);
  void (__fastcall *addPlayer)(Level *this, std::unique_ptr<Player>);
  std::unique_ptr<Actor> *(__fastcall *takeEntity)(Level *this, std::unique_ptr<Actor> *result, ActorUniqueID);
  std::unique_ptr<Actor> *(__fastcall *borrowEntity)(Level *this, std::unique_ptr<Actor> *result, ActorUniqueID, LevelChunk *);
  const Tick *(__fastcall *getCurrentServerTick)(Level *this, const Tick *result);
  Factory<BaseLightTextureImageBuilder,Level &,Scheduler &> *(__fastcall *getLightTextureImageBuilderFactory)(Level *this);
  const Factory<BaseLightTextureImageBuilder,Level &,Scheduler &> *(__fastcall *getLightTextureImageBuilderFactory)(Level *this);
  void (__fastcall *onPlayerDeath)(Level *this, Player *, const ActorDamageSource *);
  void (__fastcall *tick)(Level *this);
  void (__fastcall *directTickEntities)(Level *this, BlockSource *);
  void (__fastcall *updateSleepingPlayerList)(Level *this);
  void (__fastcall *setDifficulty)(Level *this, Difficulty);
  void (__fastcall *setCommandsEnabled)(Level *this, bool);
  void (__fastcall *setWorldTemplateOptionsUnlocked)(Level *this);
  void (__fastcall *saveAdditionalData)(Level *this);
  LevelEventCoordinator *(__fastcall *getLevelEventCoordinator)(Level *this);
  void (__fastcall *onChunkLoaded)(Level *this, ChunkSource *, LevelChunk *);
  void (__fastcall *queueEntityRemoval)(Level *this, std::unique_ptr<Actor> *, bool);
  void (__fastcall *removeEntityReferences)(Level *this, Actor *, bool);
  void (__fastcall *loadFunctionManager)(Level *this);
  ResourcePackManager *(__fastcall *getClientResourcePackManager)(Level *this);
  ResourcePackManager *(__fastcall *getServerResourcePackManager)(Level *this);
  TradeTables *(__fastcall *getTradeTables)(Level *this);
  void (__fastcall *addEntryToTagCache)(Level *this, const std::string *);
  void (__fastcall *addEntriesToTagCache)(Level *this, const std::vector<std::string>);
  void (__fastcall *dropEntryFromTagCache)(Level *this, const std::string *);
  void (__fastcall *clearTagCache)(Level *this);
  void (__fastcall *decrementTagCache)(Level *this, const std::string *, TagRegistry<IDType<LevelTagIDType>,IDType<LevelTagSetIDType> > *);
  void (__fastcall *incrementTagCache)(Level *this, const std::string *, TagRegistry<IDType<LevelTagIDType>,IDType<LevelTagSetIDType> > *);
  void (__fastcall *runCommand)(Level *this, Command *, CommandOrigin *, CommandOriginSystem);
  void (__fastcall *runCommand)(Level *this, const HashedString *, CommandOrigin *, CommandOriginSystem, const CurrentCmdVersion);
  TagRegistry<IDType<LevelTagIDType>,IDType<LevelTagSetIDType> > *(__fastcall *getTagRegistry)(Level *this);
  bool (__fastcall *canUseSkin)(Level *this, const SerializedSkin *, const NetworkIdentifier *, const mce::UUID *, const std::string *);
  PositionTrackingDB::PositionTrackingDBServer *(__fastcall *getPositionTrackerDBServer)(Level *this);
  void (__fastcall *setFinishedInitializing)(Level *this);
};

ServerPlayer_vtbl

struct /*VFT*/ ServerPlayer_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
  void (__fastcall *prepareRegion)(Player *this, ChunkSource *);
  void (__fastcall *destroyRegion)(Player *this);
  void (__fastcall *suspendRegion)(Player *this);
  void (__fastcall *resendAllChunks)(Player *this);
  void (__fastcall *_fireWillChangeDimension)(Player *this);
  void (__fastcall *_fireDimensionChanged)(Player *this);
  void (__fastcall *changeDimensionWithCredits)(Player *this, AutomaticID<Dimension,int>);
  int (__fastcall *tickWorld)(Player *this, const Tick *);
  void (__fastcall *frameUpdate)(Player *this, FrameUpdateContextBase *);
  const std::vector<ChunkPos> *(__fastcall *getTickingOffsets)(Player *this);
  void (__fastcall *moveView)(Player *this);
  void (__fastcall *setName)(Player *this, const std::string *);
  void (__fastcall *checkMovementStats)(Player *this, const Vec3 *);
  StructureFeatureType (__fastcall *getCurrentStructureFeature)(Player *this);
  bool (__fastcall *isAutoJumpEnabled)(Player *this);
  void (__fastcall *respawn)(Player *this);
  void (__fastcall *resetRot)(Player *this);
  void (__fastcall *resetPos)(Player *this, bool);
  bool (__fastcall *isInTrialMode)(Player *this);
  bool (__fastcall *hasResource)(Player *this, int);
  void (__fastcall *completeUsingItem)(Player *this);
  void (__fastcall *setPermissions)(Player *this, CommandPermissionLevel);
  void (__fastcall *startDestroying)(Player *this);
  void (__fastcall *stopDestroying)(Player *this);
  void (__fastcall *openPortfolio)(Player *this);
  void (__fastcall *openBook)(Player *this, int, bool, int, BlockActor *);
  void (__fastcall *openTrading)(Player *this, const ActorUniqueID *, bool);
  bool (__fastcall *canOpenContainerScreen)(Player *this);
  void (__fastcall *openChalkboard)(Player *this, ChalkboardBlockActor *, bool);
  void (__fastcall *openNpcInteractScreen)(Player *this, Actor *);
  bool (__fastcall *openInventory)(Player *this);
  void (__fastcall *displayChatMessage)(Player *this, const std::string *, const std::string *);
  void (__fastcall *displayClientMessage)(Player *this, const std::string *);
  void (__fastcall *displayTextObjectMessage)(Player *this, const TextObjectRoot *);
  void (__fastcall *displayTextObjectWhisperMessage)(Player *this, const ResolvedTextObject *, const std::string *, const std::string *);
  void (__fastcall *displayWhisperMessage)(Player *this, const std::string *, const std::string *, const std::string *, const std::string *);
  BedSleepingResult (__fastcall *startSleepInBed)(Player *this, const BlockPos *);
  void (__fastcall *stopSleepInBed)(Player *this, bool, bool);
  bool (__fastcall *canStartSleepInBed)(Player *this);
  int (__fastcall *getSleepTimer)(Player *this);
  int (__fastcall *getPreviousTickSleepTimer)(Player *this);
  void (__fastcall *openSign)(Player *this, const BlockPos *);
  void (__fastcall *playEmote)(Player *this, const std::string *);
  bool (__fastcall *isHostingPlayer)(Player *this);
  bool (__fastcall *isLoading)(Player *this);
  bool (__fastcall *isPlayerInitialized)(Player *this);
  void (__fastcall *stopLoading)(Player *this);
  void (__fastcall *registerTrackedBoss)(Player *this, ActorUniqueID);
  void (__fastcall *unRegisterTrackedBoss)(Player *this, ActorUniqueID);
  void (__fastcall *setPlayerGameType)(Player *this, GameType);
  void (__fastcall *initHUDContainerManager)(Player *this);
  void (__fastcall *_crit)(Player *this, Actor *);
  IMinecraftEventing *(__fastcall *getEventing)(Player *this);
  unsigned int (__fastcall *getUserId)(Player *this);
  void (__fastcall *sendEventPacket)(Player *this, EventPacket *);
  void (__fastcall *addExperience)(Player *this, int);
  void (__fastcall *addLevels)(Player *this, int);
  void (__fastcall *setContainerData)(Player *this, IContainerManager *, int, int);
  void (__fastcall *slotChanged)(Player *this, IContainerManager *, Container *, int, const ItemStack *, const ItemStack *, bool);
  void (__fastcall *inventoryChanged)(Player *this, Container *, int, const ItemStack *, const ItemStack *, bool);
  void (__fastcall *refreshContainer)(Player *this, IContainerManager *);
  void (__fastcall *deleteContainerManager)(Player *this);
  void (__fastcall *setFieldOfViewModifier)(Player *this, float);
  bool (__fastcall *is2DPositionRelevant)(Player *this, AutomaticID<Dimension,int>, const BlockPos *);
  bool (__fastcall *isEntityRelevant)(Player *this, const Actor *);
  bool (__fastcall *isTeacher)(Player *this);
  void (__fastcall *onSuspension)(Player *this);
  void (__fastcall *onLinkedSlotsChanged)(Player *this);
  void (__fastcall *startCooldown)(Player *this, const Item *);
  int (__fastcall *getItemCooldownLeft)(Player *this, const std::string *);
  bool (__fastcall *isItemInCooldown)(Player *this, const std::string *);
  void (__fastcall *sendInventoryTransaction)(Player *this, const InventoryTransaction *);
  void (__fastcall *sendComplexInventoryTransaction)(Player *this, std::unique_ptr<ComplexInventoryTransaction>);
  void (__fastcall *sendNetworkPacket)(Player *this, Packet *);
  PlayerEventCoordinator *(__fastcall *getPlayerEventCoordinator)(Player *this);
  MoveInputHandler *(__fastcall *getMoveInputHandler)(Player *this);
  InputMode (__fastcall *getInputMode)(Player *this);
  ClientPlayMode (__fastcall *getPlayMode)(Player *this);
  void (__fastcall *reportMovementTelemetry)(Player *this, const MovementEventType);
  bool (__fastcall *getCamereDeparted)(Player *this);
  bool (__fastcall *getThirdPersonPerspective)(Player *this);
  Vec2 *(__fastcall *getRotationToCamera)(Player *this, Vec2 *result);
  void (__fastcall *onMovePlayerPacketNormal)(Player *this, const Vec3 *, const Vec2 *, float);
};

Shulker_vtbl

struct /*VFT*/ Shulker_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
};

Silverfish_vtbl

struct /*VFT*/ Silverfish_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
  bool (__fastcall *isDarkEnoughToSpawn)(Monster *this);
};

SkullBlockActor_vtbl

struct /*VFT*/ SkullBlockActor_vtbl
{
  void (__fastcall *~BlockActor)(BlockActor *this);
  void (__fastcall *load)(BlockActor *this, Level *, const CompoundTag *, DataLoadHelper *);
  bool (__fastcall *save)(BlockActor *this, CompoundTag *);
  bool (__fastcall *saveItemInstanceData)(BlockActor *this, CompoundTag *);
  void (__fastcall *saveBlockData)(BlockActor *this, CompoundTag *, BlockSource *);
  void (__fastcall *loadBlockData)(BlockActor *this, const CompoundTag *, BlockSource *, DataLoadHelper *);
  void (__fastcall *onCustomTagLoadDone)(BlockActor *this, BlockSource *);
  void (__fastcall *tick)(BlockActor *this, BlockSource *);
  bool (__fastcall *isFinished)(BlockActor *this);
  void (__fastcall *onChanged)(BlockActor *this, BlockSource *);
  bool (__fastcall *isMovable)(BlockActor *this, BlockSource *);
  bool (__fastcall *isCustomNameSaved)(BlockActor *this);
  bool (__fastcall *onUpdatePacket)(BlockActor *this, const CompoundTag *, BlockSource *, const Player *);
  void (__fastcall *onPlace)(BlockActor *this, BlockSource *);
  void (__fastcall *onMove)(BlockActor *this);
  void (__fastcall *onRemoved)(BlockActor *this, BlockSource *);
  void (__fastcall *triggerEvent)(BlockActor *this, int, int);
  void (__fastcall *clearCache)(BlockActor *this);
  void (__fastcall *onNeighborChanged)(BlockActor *this, BlockSource *, const BlockPos *);
  float (__fastcall *getShadowRadius)(BlockActor *this, BlockSource *);
  bool (__fastcall *hasAlphaLayer)(BlockActor *this);
  BlockActor *(__fastcall *getCrackEntity)(BlockActor *this, BlockSource *, const BlockPos *);
  void (__fastcall *getDebugText)(BlockActor *this, std::vector<std::string> *, const BlockPos *);
  const std::string *(__fastcall *getCustomName)(BlockActor *this);
  const std::string *(__fastcall *getFilteredCustomName)(BlockActor *this, const UIProfanityContext *);
  std::string *(__fastcall *getName)(BlockActor *this, std::string *result);
  void (__fastcall *setCustomName)(BlockActor *this, const std::string *);
  std::string *(__fastcall *getImmersiveReaderText)(BlockActor *this, std::string *result, BlockSource *);
  int (__fastcall *getRepairCost)(BlockActor *this);
  PistonBlockActor *(__fastcall *getOwningPiston)(BlockActor *this, BlockSource *);
  const Container *(__fastcall *getContainer)(BlockActor *this);
  Container *(__fastcall *getContainer)(BlockActor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(BlockActor *this);
  void (__fastcall *checkWordsOnChunkLoad)(BlockActor *this, LevelChunk *);
  void (__fastcall *checkWordsOnUpdate)(BlockActor *this, Player *);
  void (__fastcall *onChunkLoaded)(BlockActor *this, LevelChunk *);
  void (__fastcall *onChunkUnloaded)(BlockActor *this, LevelChunk *);
  std::unique_ptr<BlockActorDataPacket> *(__fastcall *_getUpdatePacket)(BlockActor *this, std::unique_ptr<BlockActorDataPacket> *result, BlockSource *);
  void (__fastcall *_onUpdatePacket)(BlockActor *this, const CompoundTag *, BlockSource *);
  bool (__fastcall *_playerCanUpdate)(BlockActor *this, const Player *);
};

Slime_vtbl

struct /*VFT*/ Slime_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
  bool (__fastcall *isDarkEnoughToSpawn)(Monster *this);
  bool (__fastcall *canDealDamage)(Slime *this);
  LevelSoundEvent (__fastcall *getSquishSound)(Slime *this);
  void (__fastcall *setSlimeSize)(Slime *this, int);
  bool (__fastcall *doPlayJumpSound)(Slime *this);
  bool (__fastcall *doPlayLandSound)(Slime *this);
  void (__fastcall *playJumpSound)(Slime *this);
  void (__fastcall *playLandSound)(Slime *this);
  void (__fastcall *decreaseSquish)(Slime *this);
  std::unique_ptr<Slime> *(__fastcall *createChild)(Slime *this, std::unique_ptr<Slime> *result, int);
};

Spider_vtbl

struct /*VFT*/ Spider_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
  bool (__fastcall *isDarkEnoughToSpawn)(Monster *this);
  float (__fastcall *getModelScale)(Spider *this);
  Spider::Type (__fastcall *getSpiderType)(Spider *this);
};

Squid_vtbl

struct /*VFT*/ Squid_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
};

SubChunkBlockStoragePaletted<1,1>_vtbl

struct /*VFT*/ SubChunkBlockStoragePaletted<1,1>_vtbl
{
  void (__fastcall *~SubChunkBlockStorage)(SubChunkBlockStorage *this);
  bool (__fastcall *isUniform)(SubChunkBlockStorage *this, const Block *);
  const Block *(__fastcall *getBlock)(SubChunkBlockStorage *this, unsigned __int16);
  bool (__fastcall *setBlock)(SubChunkBlockStorage *this, unsigned __int16, const Block *);
  unsigned __int64 (__fastcall *getBlockTypeCapacity)(SubChunkBlockStorage *this);
  SubChunkBlockStorage::Type (__fastcall *getType)(SubChunkBlockStorage *this);
  std::unique_ptr<SubChunkBlockStorage> *(__fastcall *makePrunedCopy)(SubChunkBlockStorage *this, std::unique_ptr<SubChunkBlockStorage> *result, SubChunkBlockStorage::PruneType);
  bool (__fastcall *hasModFlag)(SubChunkBlockStorage *this);
  void (__fastcall *setModFlag)(SubChunkBlockStorage *this, bool);
  const ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  void (__fastcall *fetchBlocksInCylinder)(SubChunkBlockStorage *this, const BlockPos *, const BlockPos *, unsigned int, unsigned int, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *fetchBlocksInBox)(SubChunkBlockStorage *this, const BlockPos *, const BoundingBox *, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *_serialize)(SubChunkBlockStorage *this, IDataOutput *, bool);
  gsl::span<unsigned int const ,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int const ,-1> *result);
  gsl::span<unsigned int,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int,-1> *result);
  unsigned __int64 (__fastcall *getBitsPerBlock)(ISubChunkBlockStoragePaletted *this);
  gsl::span<Block const * const,-1> *(__fastcall *getPaletteSnapshot)(ISubChunkBlockStoragePaletted *this, gsl::span<Block const * const,-1> *result);
};

SubChunkBlockStoragePaletted<16,16>_vtbl

struct /*VFT*/ SubChunkBlockStoragePaletted<16,16>_vtbl
{
  void (__fastcall *~SubChunkBlockStorage)(SubChunkBlockStorage *this);
  bool (__fastcall *isUniform)(SubChunkBlockStorage *this, const Block *);
  const Block *(__fastcall *getBlock)(SubChunkBlockStorage *this, unsigned __int16);
  bool (__fastcall *setBlock)(SubChunkBlockStorage *this, unsigned __int16, const Block *);
  unsigned __int64 (__fastcall *getBlockTypeCapacity)(SubChunkBlockStorage *this);
  SubChunkBlockStorage::Type (__fastcall *getType)(SubChunkBlockStorage *this);
  std::unique_ptr<SubChunkBlockStorage> *(__fastcall *makePrunedCopy)(SubChunkBlockStorage *this, std::unique_ptr<SubChunkBlockStorage> *result, SubChunkBlockStorage::PruneType);
  bool (__fastcall *hasModFlag)(SubChunkBlockStorage *this);
  void (__fastcall *setModFlag)(SubChunkBlockStorage *this, bool);
  const ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  void (__fastcall *fetchBlocksInCylinder)(SubChunkBlockStorage *this, const BlockPos *, const BlockPos *, unsigned int, unsigned int, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *fetchBlocksInBox)(SubChunkBlockStorage *this, const BlockPos *, const BoundingBox *, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *_serialize)(SubChunkBlockStorage *this, IDataOutput *, bool);
  gsl::span<unsigned int const ,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int const ,-1> *result);
  gsl::span<unsigned int,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int,-1> *result);
  unsigned __int64 (__fastcall *getBitsPerBlock)(ISubChunkBlockStoragePaletted *this);
  gsl::span<Block const * const,-1> *(__fastcall *getPaletteSnapshot)(ISubChunkBlockStoragePaletted *this, gsl::span<Block const * const,-1> *result);
};

SubChunkBlockStoragePaletted<2,2>_vtbl

struct /*VFT*/ SubChunkBlockStoragePaletted<2,2>_vtbl
{
  void (__fastcall *~SubChunkBlockStorage)(SubChunkBlockStorage *this);
  bool (__fastcall *isUniform)(SubChunkBlockStorage *this, const Block *);
  const Block *(__fastcall *getBlock)(SubChunkBlockStorage *this, unsigned __int16);
  bool (__fastcall *setBlock)(SubChunkBlockStorage *this, unsigned __int16, const Block *);
  unsigned __int64 (__fastcall *getBlockTypeCapacity)(SubChunkBlockStorage *this);
  SubChunkBlockStorage::Type (__fastcall *getType)(SubChunkBlockStorage *this);
  std::unique_ptr<SubChunkBlockStorage> *(__fastcall *makePrunedCopy)(SubChunkBlockStorage *this, std::unique_ptr<SubChunkBlockStorage> *result, SubChunkBlockStorage::PruneType);
  bool (__fastcall *hasModFlag)(SubChunkBlockStorage *this);
  void (__fastcall *setModFlag)(SubChunkBlockStorage *this, bool);
  const ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  void (__fastcall *fetchBlocksInCylinder)(SubChunkBlockStorage *this, const BlockPos *, const BlockPos *, unsigned int, unsigned int, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *fetchBlocksInBox)(SubChunkBlockStorage *this, const BlockPos *, const BoundingBox *, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *_serialize)(SubChunkBlockStorage *this, IDataOutput *, bool);
  gsl::span<unsigned int const ,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int const ,-1> *result);
  gsl::span<unsigned int,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int,-1> *result);
  unsigned __int64 (__fastcall *getBitsPerBlock)(ISubChunkBlockStoragePaletted *this);
  gsl::span<Block const * const,-1> *(__fastcall *getPaletteSnapshot)(ISubChunkBlockStoragePaletted *this, gsl::span<Block const * const,-1> *result);
};

SubChunkBlockStoragePaletted<3,3>_vtbl

struct /*VFT*/ SubChunkBlockStoragePaletted<3,3>_vtbl
{
  void (__fastcall *~SubChunkBlockStorage)(SubChunkBlockStorage *this);
  bool (__fastcall *isUniform)(SubChunkBlockStorage *this, const Block *);
  const Block *(__fastcall *getBlock)(SubChunkBlockStorage *this, unsigned __int16);
  bool (__fastcall *setBlock)(SubChunkBlockStorage *this, unsigned __int16, const Block *);
  unsigned __int64 (__fastcall *getBlockTypeCapacity)(SubChunkBlockStorage *this);
  SubChunkBlockStorage::Type (__fastcall *getType)(SubChunkBlockStorage *this);
  std::unique_ptr<SubChunkBlockStorage> *(__fastcall *makePrunedCopy)(SubChunkBlockStorage *this, std::unique_ptr<SubChunkBlockStorage> *result, SubChunkBlockStorage::PruneType);
  bool (__fastcall *hasModFlag)(SubChunkBlockStorage *this);
  void (__fastcall *setModFlag)(SubChunkBlockStorage *this, bool);
  const ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  void (__fastcall *fetchBlocksInCylinder)(SubChunkBlockStorage *this, const BlockPos *, const BlockPos *, unsigned int, unsigned int, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *fetchBlocksInBox)(SubChunkBlockStorage *this, const BlockPos *, const BoundingBox *, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *_serialize)(SubChunkBlockStorage *this, IDataOutput *, bool);
  gsl::span<unsigned int const ,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int const ,-1> *result);
  gsl::span<unsigned int,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int,-1> *result);
  unsigned __int64 (__fastcall *getBitsPerBlock)(ISubChunkBlockStoragePaletted *this);
  gsl::span<Block const * const,-1> *(__fastcall *getPaletteSnapshot)(ISubChunkBlockStoragePaletted *this, gsl::span<Block const * const,-1> *result);
};

SubChunkBlockStoragePaletted<4,4>_vtbl

struct /*VFT*/ SubChunkBlockStoragePaletted<4,4>_vtbl
{
  void (__fastcall *~SubChunkBlockStorage)(SubChunkBlockStorage *this);
  bool (__fastcall *isUniform)(SubChunkBlockStorage *this, const Block *);
  const Block *(__fastcall *getBlock)(SubChunkBlockStorage *this, unsigned __int16);
  bool (__fastcall *setBlock)(SubChunkBlockStorage *this, unsigned __int16, const Block *);
  unsigned __int64 (__fastcall *getBlockTypeCapacity)(SubChunkBlockStorage *this);
  SubChunkBlockStorage::Type (__fastcall *getType)(SubChunkBlockStorage *this);
  std::unique_ptr<SubChunkBlockStorage> *(__fastcall *makePrunedCopy)(SubChunkBlockStorage *this, std::unique_ptr<SubChunkBlockStorage> *result, SubChunkBlockStorage::PruneType);
  bool (__fastcall *hasModFlag)(SubChunkBlockStorage *this);
  void (__fastcall *setModFlag)(SubChunkBlockStorage *this, bool);
  const ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  void (__fastcall *fetchBlocksInCylinder)(SubChunkBlockStorage *this, const BlockPos *, const BlockPos *, unsigned int, unsigned int, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *fetchBlocksInBox)(SubChunkBlockStorage *this, const BlockPos *, const BoundingBox *, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *_serialize)(SubChunkBlockStorage *this, IDataOutput *, bool);
  gsl::span<unsigned int const ,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int const ,-1> *result);
  gsl::span<unsigned int,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int,-1> *result);
  unsigned __int64 (__fastcall *getBitsPerBlock)(ISubChunkBlockStoragePaletted *this);
  gsl::span<Block const * const,-1> *(__fastcall *getPaletteSnapshot)(ISubChunkBlockStoragePaletted *this, gsl::span<Block const * const,-1> *result);
};

SubChunkBlockStoragePaletted<5,5>_vtbl

struct /*VFT*/ SubChunkBlockStoragePaletted<5,5>_vtbl
{
  void (__fastcall *~SubChunkBlockStorage)(SubChunkBlockStorage *this);
  bool (__fastcall *isUniform)(SubChunkBlockStorage *this, const Block *);
  const Block *(__fastcall *getBlock)(SubChunkBlockStorage *this, unsigned __int16);
  bool (__fastcall *setBlock)(SubChunkBlockStorage *this, unsigned __int16, const Block *);
  unsigned __int64 (__fastcall *getBlockTypeCapacity)(SubChunkBlockStorage *this);
  SubChunkBlockStorage::Type (__fastcall *getType)(SubChunkBlockStorage *this);
  std::unique_ptr<SubChunkBlockStorage> *(__fastcall *makePrunedCopy)(SubChunkBlockStorage *this, std::unique_ptr<SubChunkBlockStorage> *result, SubChunkBlockStorage::PruneType);
  bool (__fastcall *hasModFlag)(SubChunkBlockStorage *this);
  void (__fastcall *setModFlag)(SubChunkBlockStorage *this, bool);
  const ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  void (__fastcall *fetchBlocksInCylinder)(SubChunkBlockStorage *this, const BlockPos *, const BlockPos *, unsigned int, unsigned int, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *fetchBlocksInBox)(SubChunkBlockStorage *this, const BlockPos *, const BoundingBox *, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *_serialize)(SubChunkBlockStorage *this, IDataOutput *, bool);
  gsl::span<unsigned int const ,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int const ,-1> *result);
  gsl::span<unsigned int,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int,-1> *result);
  unsigned __int64 (__fastcall *getBitsPerBlock)(ISubChunkBlockStoragePaletted *this);
  gsl::span<Block const * const,-1> *(__fastcall *getPaletteSnapshot)(ISubChunkBlockStoragePaletted *this, gsl::span<Block const * const,-1> *result);
};

SubChunkBlockStoragePaletted<6,6>_vtbl

struct /*VFT*/ SubChunkBlockStoragePaletted<6,6>_vtbl
{
  void (__fastcall *~SubChunkBlockStorage)(SubChunkBlockStorage *this);
  bool (__fastcall *isUniform)(SubChunkBlockStorage *this, const Block *);
  const Block *(__fastcall *getBlock)(SubChunkBlockStorage *this, unsigned __int16);
  bool (__fastcall *setBlock)(SubChunkBlockStorage *this, unsigned __int16, const Block *);
  unsigned __int64 (__fastcall *getBlockTypeCapacity)(SubChunkBlockStorage *this);
  SubChunkBlockStorage::Type (__fastcall *getType)(SubChunkBlockStorage *this);
  std::unique_ptr<SubChunkBlockStorage> *(__fastcall *makePrunedCopy)(SubChunkBlockStorage *this, std::unique_ptr<SubChunkBlockStorage> *result, SubChunkBlockStorage::PruneType);
  bool (__fastcall *hasModFlag)(SubChunkBlockStorage *this);
  void (__fastcall *setModFlag)(SubChunkBlockStorage *this, bool);
  const ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  void (__fastcall *fetchBlocksInCylinder)(SubChunkBlockStorage *this, const BlockPos *, const BlockPos *, unsigned int, unsigned int, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *fetchBlocksInBox)(SubChunkBlockStorage *this, const BlockPos *, const BoundingBox *, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *_serialize)(SubChunkBlockStorage *this, IDataOutput *, bool);
  gsl::span<unsigned int const ,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int const ,-1> *result);
  gsl::span<unsigned int,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int,-1> *result);
  unsigned __int64 (__fastcall *getBitsPerBlock)(ISubChunkBlockStoragePaletted *this);
  gsl::span<Block const * const,-1> *(__fastcall *getPaletteSnapshot)(ISubChunkBlockStoragePaletted *this, gsl::span<Block const * const,-1> *result);
};

SubChunkBlockStoragePaletted<8,8>_vtbl

struct /*VFT*/ SubChunkBlockStoragePaletted<8,8>_vtbl
{
  void (__fastcall *~SubChunkBlockStorage)(SubChunkBlockStorage *this);
  bool (__fastcall *isUniform)(SubChunkBlockStorage *this, const Block *);
  const Block *(__fastcall *getBlock)(SubChunkBlockStorage *this, unsigned __int16);
  bool (__fastcall *setBlock)(SubChunkBlockStorage *this, unsigned __int16, const Block *);
  unsigned __int64 (__fastcall *getBlockTypeCapacity)(SubChunkBlockStorage *this);
  SubChunkBlockStorage::Type (__fastcall *getType)(SubChunkBlockStorage *this);
  std::unique_ptr<SubChunkBlockStorage> *(__fastcall *makePrunedCopy)(SubChunkBlockStorage *this, std::unique_ptr<SubChunkBlockStorage> *result, SubChunkBlockStorage::PruneType);
  bool (__fastcall *hasModFlag)(SubChunkBlockStorage *this);
  void (__fastcall *setModFlag)(SubChunkBlockStorage *this, bool);
  const ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  ISubChunkBlockStoragePaletted *(__fastcall *asPalettedStorage)(SubChunkBlockStorage *this);
  void (__fastcall *fetchBlocksInCylinder)(SubChunkBlockStorage *this, const BlockPos *, const BlockPos *, unsigned int, unsigned int, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *fetchBlocksInBox)(SubChunkBlockStorage *this, const BlockPos *, const BoundingBox *, const std::function<bool __cdecl(Block const &)> *, std::vector<BlockFetchResult> *);
  void (__fastcall *_serialize)(SubChunkBlockStorage *this, IDataOutput *, bool);
  gsl::span<unsigned int const ,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int const ,-1> *result);
  gsl::span<unsigned int,-1> *(__fastcall *getBlocks)(ISubChunkBlockStoragePaletted *this, gsl::span<unsigned int,-1> *result);
  unsigned __int64 (__fastcall *getBitsPerBlock)(ISubChunkBlockStoragePaletted *this);
  gsl::span<Block const * const,-1> *(__fastcall *getPaletteSnapshot)(ISubChunkBlockStoragePaletted *this, gsl::span<Block const * const,-1> *result);
};

Salmon_vtbl

struct /*VFT*/ Salmon_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
};

Sheep_vtbl

struct /*VFT*/ Sheep_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
};

ShulkerBoxBlockActor_vtbl

struct /*VFT*/ ShulkerBoxBlockActor_vtbl
{
  void (__fastcall *~BlockActor)(BlockActor *this);
  void (__fastcall *load)(BlockActor *this, Level *, const CompoundTag *, DataLoadHelper *);
  bool (__fastcall *save)(BlockActor *this, CompoundTag *);
  bool (__fastcall *saveItemInstanceData)(BlockActor *this, CompoundTag *);
  void (__fastcall *saveBlockData)(BlockActor *this, CompoundTag *, BlockSource *);
  void (__fastcall *loadBlockData)(BlockActor *this, const CompoundTag *, BlockSource *, DataLoadHelper *);
  void (__fastcall *onCustomTagLoadDone)(BlockActor *this, BlockSource *);
  void (__fastcall *tick)(BlockActor *this, BlockSource *);
  bool (__fastcall *isFinished)(BlockActor *this);
  void (__fastcall *onChanged)(BlockActor *this, BlockSource *);
  bool (__fastcall *isMovable)(BlockActor *this, BlockSource *);
  bool (__fastcall *isCustomNameSaved)(BlockActor *this);
  bool (__fastcall *onUpdatePacket)(BlockActor *this, const CompoundTag *, BlockSource *, const Player *);
  void (__fastcall *onPlace)(BlockActor *this, BlockSource *);
  void (__fastcall *onMove)(BlockActor *this);
  void (__fastcall *onRemoved)(BlockActor *this, BlockSource *);
  void (__fastcall *triggerEvent)(BlockActor *this, int, int);
  void (__fastcall *clearCache)(BlockActor *this);
  void (__fastcall *onNeighborChanged)(BlockActor *this, BlockSource *, const BlockPos *);
  float (__fastcall *getShadowRadius)(BlockActor *this, BlockSource *);
  bool (__fastcall *hasAlphaLayer)(BlockActor *this);
  BlockActor *(__fastcall *getCrackEntity)(BlockActor *this, BlockSource *, const BlockPos *);
  void (__fastcall *getDebugText)(BlockActor *this, std::vector<std::string> *, const BlockPos *);
  const std::string *(__fastcall *getCustomName)(BlockActor *this);
  const std::string *(__fastcall *getFilteredCustomName)(BlockActor *this, const UIProfanityContext *);
  std::string *(__fastcall *getName)(BlockActor *this, std::string *result);
  void (__fastcall *setCustomName)(BlockActor *this, const std::string *);
  std::string *(__fastcall *getImmersiveReaderText)(BlockActor *this, std::string *result, BlockSource *);
  int (__fastcall *getRepairCost)(BlockActor *this);
  PistonBlockActor *(__fastcall *getOwningPiston)(BlockActor *this, BlockSource *);
  const Container *(__fastcall *getContainer)(BlockActor *this);
  Container *(__fastcall *getContainer)(BlockActor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(BlockActor *this);
  void (__fastcall *checkWordsOnChunkLoad)(BlockActor *this, LevelChunk *);
  void (__fastcall *checkWordsOnUpdate)(BlockActor *this, Player *);
  void (__fastcall *onChunkLoaded)(BlockActor *this, LevelChunk *);
  void (__fastcall *onChunkUnloaded)(BlockActor *this, LevelChunk *);
  std::unique_ptr<BlockActorDataPacket> *(__fastcall *_getUpdatePacket)(BlockActor *this, std::unique_ptr<BlockActorDataPacket> *result, BlockSource *);
  void (__fastcall *_onUpdatePacket)(BlockActor *this, const CompoundTag *, BlockSource *);
  bool (__fastcall *_playerCanUpdate)(BlockActor *this, const Player *);
  void (__fastcall *loadItems)(ChestBlockActor *this, const CompoundTag *, Level *);
  bool (__fastcall *saveItems)(ChestBlockActor *this, CompoundTag *);
  void (__fastcall *playOpenSound)(ChestBlockActor *this, BlockSource *);
  void (__fastcall *playCloseSound)(ChestBlockActor *this, BlockSource *);
  bool (__fastcall *_canOpenThis)(ChestBlockActor *this, BlockSource *);
  AABB *(__fastcall *getObstructionAABB)(ChestBlockActor *this, AABB *result);
  bool (__fastcall *_detectEntityObstruction)(ChestBlockActor *this, BlockSource *);
};

Skeleton_vtbl

struct /*VFT*/ Skeleton_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
  bool (__fastcall *isDarkEnoughToSpawn)(Monster *this);
};

Strider_vtbl

struct /*VFT*/ Strider_vtbl
{
  bool (__fastcall *hasComponent)(Actor *this, const HashedString *);
  void (__fastcall *reloadHardcoded)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadHardcodedClient)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *initializeComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *reloadComponents)(Actor *this, Actor::InitializationMethod, const VariantParameterList *);
  void (__fastcall *_serverInitItemStackIds)(Actor *this);
  void (__fastcall *_doInitialMove)(Actor *this);
  bool (__fastcall *checkAllSensitiveWords)(Actor *this);
  bool (__fastcall *checkNameTag)(Actor *this);
  void (__fastcall *~Actor)(Actor *this);
  void (__fastcall *reset)(Actor *this);
  int (__fastcall *getOnDeathExperience)(Actor *this);
  ActorType (__fastcall *getOwnerEntityType)(Actor *this);
  void (__fastcall *remove)(Actor *this);
  void (__fastcall *setPos)(Actor *this, const Vec3 *);
  const PredictedMovementValues *(__fastcall *getPredictedMovementValues)(Actor *this);
  const Vec3 *(__fastcall *getPos)(Actor *this);
  const Vec3 *(__fastcall *getPosOld)(Actor *this);
  const Vec3 *(__fastcall *getPosExtrapolated)(Actor *this, const Vec3 *result, float);
  Vec3 *(__fastcall *getAttachPos)(Actor *this, Vec3 *result, ActorLocation, float);
  Vec3 *(__fastcall *getFiringPos)(Actor *this, Vec3 *result);
  void (__fastcall *setRot)(Actor *this, const Vec2 *);
  void (__fastcall *move)(Actor *this, IActorMovementProxy *, const Vec3 *);
  void (__fastcall *move)(Actor *this, const Vec3 *);
  Vec3 *(__fastcall *getInterpolatedRidingPosition)(Actor *this, Vec3 *result, float);
  float (__fastcall *getInterpolatedBodyRot)(Actor *this, float);
  float (__fastcall *getInterpolatedHeadRot)(Actor *this, float);
  float (__fastcall *getInterpolatedBodyYaw)(Actor *this, float);
  float (__fastcall *getYawSpeedInDegreesPerSecond)(Actor *this);
  float (__fastcall *getInterpolatedWalkAnimSpeed)(Actor *this, float);
  Vec3 *(__fastcall *getInterpolatedRidingOffset)(Actor *this, Vec3 *result, float);
  void (__fastcall *checkBlockCollisions)(Actor *this);
  void (__fastcall *checkBlockCollisions)(Actor *this, const AABB *, std::function<void __cdecl(BlockSource &,Block const &,BlockPos const &,Actor &)>);
  bool (__fastcall *isFireImmune)(Actor *this);
  bool (__fastcall *breaksFallingBlocks)(Actor *this);
  void (__fastcall *blockedByShield)(Actor *this, const ActorDamageSource *, Actor *);
  void (__fastcall *teleportTo)(Actor *this, const Vec3 *, bool, int, int, const ActorUniqueID *);
  bool (__fastcall *tryTeleportTo)(Actor *this, const Vec3 *, bool, bool, int, int);
  void (__fastcall *chorusFruitTeleport)(Actor *this, Vec3 *);
  void (__fastcall *lerpTo)(Actor *this, const Vec3 *, const Vec2 *, int);
  void (__fastcall *lerpMotion)(Actor *this, const Vec3 *);
  std::unique_ptr<AddActorBasePacket> *(__fastcall *getAddPacket)(Actor *this, std::unique_ptr<AddActorBasePacket> *result);
  void (__fastcall *normalTick)(Actor *this);
  void (__fastcall *baseTick)(Actor *this);
  void (__fastcall *rideTick)(Actor *this);
  void (__fastcall *positionRider)(Actor *this, Actor *, float);
  float (__fastcall *getRidingHeight)(Actor *this);
  bool (__fastcall *startRiding)(Actor *this, Actor *);
  void (__fastcall *addRider)(Actor *this, Actor *);
  void (__fastcall *flagRiderToRemove)(Actor *this, Actor *);
  std::string *(__fastcall *getExitTip)(Actor *this, std::string *result, const std::string *, InputMode);
  bool (__fastcall *intersects)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *);
  bool (__fastcall *isFree)(Actor *this, const Vec3 *, float);
  bool (__fastcall *isInWall)(Actor *this);
  bool (__fastcall *isInvisible)(Actor *this);
  bool (__fastcall *canShowNameTag)(Actor *this);
  bool (__fastcall *canExistInPeaceful)(Actor *this);
  void (__fastcall *setNameTagVisible)(Actor *this, bool);
  const std::string *(__fastcall *getNameTag)(Actor *this);
  unsigned __int64 (__fastcall *getNameTagAsHash)(Actor *this);
  std::string *(__fastcall *getFormattedNameTag)(Actor *this, std::string *result);
  void (__fastcall *filterFormattedNameTag)(Actor *this, const UIProfanityContext *);
  void (__fastcall *setNameTag)(Actor *this, const std::string *);
  bool (__fastcall *getAlwaysShowNameTag)(Actor *this);
  void (__fastcall *setScoreTag)(Actor *this, const std::string *);
  const std::string *(__fastcall *getScoreTag)(Actor *this);
  bool (__fastcall *isInWater)(Actor *this);
  bool (__fastcall *hasEnteredWater)(Actor *this);
  bool (__fastcall *isImmersedInWater)(Actor *this);
  bool (__fastcall *isInWaterOrRain)(Actor *this);
  bool (__fastcall *isInLava)(Actor *this);
  bool (__fastcall *isUnderLiquid)(Actor *this, MaterialType);
  bool (__fastcall *isOverWater)(Actor *this);
  void (__fastcall *makeStuckInBlock)(Actor *this, const Vec3 *);
  float (__fastcall *getCameraOffset)(Actor *this);
  float (__fastcall *getShadowHeightOffs)(Actor *this);
  float (__fastcall *getShadowRadius)(Actor *this);
  Vec3 *(__fastcall *getHeadLookVector)(Actor *this, Vec3 *result, float);
  bool (__fastcall *canSeeInvisible)(Actor *this);
  bool (__fastcall *canSee)(Actor *this, const Vec3 *);
  bool (__fastcall *canSee)(Actor *this, const Actor *);
  bool (__fastcall *isSkyLit)(Actor *this, float);
  float (__fastcall *getBrightness)(Actor *this, float);
  bool (__fastcall *interactPreventDefault)(Actor *this);
  void (__fastcall *playerTouch)(Actor *this, Player *);
  void (__fastcall *onAboveBubbleColumn)(Actor *this, const bool);
  void (__fastcall *onInsideBubbleColumn)(Actor *this, const bool);
  bool (__fastcall *isImmobile)(Actor *this);
  bool (__fastcall *isSilent)(Actor *this);
  bool (__fastcall *isPickable)(Actor *this);
  bool (__fastcall *isFishable)(Actor *this);
  bool (__fastcall *isSleeping)(Actor *this);
  bool (__fastcall *isShootable)(Actor *this);
  void (__fastcall *setSneaking)(Actor *this, bool);
  bool (__fastcall *isBlocking)(Actor *this);
  bool (__fastcall *isDamageBlocked)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *isAlive)(Actor *this);
  bool (__fastcall *isOnFire)(Actor *this);
  bool (__fastcall *isOnHotBlock)(Actor *this);
  bool (__fastcall *isCreativeModeAllowed)(Actor *this);
  bool (__fastcall *isSurfaceMob)(Actor *this);
  bool (__fastcall *isTargetable)(Actor *this);
  bool (__fastcall *isLocalPlayer)(Actor *this);
  bool (__fastcall *isPlayer)(Actor *this);
  bool (__fastcall *canAttack)(Actor *this, Actor *, bool);
  void (__fastcall *setTarget)(Actor *this, Actor *);
  Actor *(__fastcall *findAttackTarget)(Actor *this);
  bool (__fastcall *isValidTarget)(Actor *this, Actor *);
  bool (__fastcall *attack)(Actor *this, Actor *);
  void (__fastcall *performRangedAttack)(Actor *this, Actor *, float);
  void (__fastcall *adjustDamageAmount)(Actor *this, int *);
  int (__fastcall *getEquipmentCount)(Actor *this);
  void (__fastcall *setOwner)(Actor *this, const ActorUniqueID);
  void (__fastcall *setSitting)(Actor *this, bool);
  void (__fastcall *onTame)(Actor *this);
  void (__fastcall *onFailedTame)(Actor *this);
  int (__fastcall *getInventorySize)(Actor *this);
  int (__fastcall *getEquipSlots)(Actor *this);
  int (__fastcall *getChestSlots)(Actor *this);
  void (__fastcall *setStanding)(Actor *this, bool);
  bool (__fastcall *canPowerJump)(Actor *this);
  void (__fastcall *setCanPowerJump)(Actor *this, bool);
  bool (__fastcall *isJumping)(Actor *this);
  bool (__fastcall *isEnchanted)(Actor *this);
  void (__fastcall *rideJumped)(Actor *this);
  void (__fastcall *rideLanded)(Actor *this, const Vec3 *, const Vec3 *);
  bool (__fastcall *shouldRender)(Actor *this);
  bool (__fastcall *isInvulnerableTo)(Actor *this, const ActorDamageSource *);
  ActorDamageCause (__fastcall *getBlockDamageCause)(Actor *this, const Block *);
  void (__fastcall *actuallyHurt)(Actor *this, int, const ActorDamageSource *, bool);
  void (__fastcall *animateHurt)(Actor *this);
  bool (__fastcall *doFireHurt)(Actor *this, int);
  void (__fastcall *onLightningHit)(Actor *this);
  void (__fastcall *onBounceStarted)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *feed)(Actor *this, int);
  void (__fastcall *handleEntityEvent)(Actor *this, ActorEvent, int);
  float (__fastcall *getPickRadius)(Actor *this);
  const HashedString *(__fastcall *getActorRendererId)(Actor *this);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const ItemStack *, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, const Block *, int);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int, float);
  ItemActor *(__fastcall *spawnAtLocation)(Actor *this, int, int);
  void (__fastcall *despawn)(Actor *this);
  void (__fastcall *killed)(Actor *this, Actor *);
  void (__fastcall *awardKillScore)(Actor *this, Actor *, int);
  void (__fastcall *setArmor)(Actor *this, ArmorSlot, const ItemStack *);
  const ItemStack *(__fastcall *getArmor)(Actor *this, ArmorSlot);
  ArmorMaterialType (__fastcall *getArmorMaterialTypeInSlot)(Actor *this, ArmorSlot);
  ArmorTextureType (__fastcall *getArmorMaterialTextureTypeInSlot)(Actor *this, ArmorSlot);
  float (__fastcall *getArmorColorInSlot)(Actor *this, ArmorSlot, int);
  const ItemStack *(__fastcall *getEquippedSlot)(Actor *this, EquipmentSlot);
  void (__fastcall *setEquippedSlot)(Actor *this, EquipmentSlot, const ItemStack *);
  const ItemStack *(__fastcall *getCarriedItem)(Actor *this);
  void (__fastcall *setCarriedItem)(Actor *this, const ItemStack *);
  void (__fastcall *setOffhandSlot)(Actor *this, const ItemStack *);
  const ItemStack *(__fastcall *getEquippedTotem)(Actor *this);
  bool (__fastcall *consumeTotem)(Actor *this);
  bool (__fastcall *save)(Actor *this, CompoundTag *);
  void (__fastcall *saveWithoutId)(Actor *this, CompoundTag *);
  bool (__fastcall *load)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *loadLinks)(Actor *this, const CompoundTag *, std::vector<ActorLink> *, DataLoadHelper *);
  ActorType (__fastcall *getEntityTypeId)(Actor *this);
  const HashedString *(__fastcall *queryEntityRenderer)(Actor *this);
  ActorUniqueID *(__fastcall *getSourceUniqueID)(Actor *this, ActorUniqueID *result);
  void (__fastcall *setOnFire)(Actor *this, int);
  AABB *(__fastcall *getHandleWaterAABB)(Actor *this, AABB *result);
  void (__fastcall *handleInsidePortal)(Actor *this, const BlockPos *);
  int (__fastcall *getPortalCooldown)(Actor *this);
  int (__fastcall *getPortalWaitTime)(Actor *this);
  AutomaticID<Dimension,int> *(__fastcall *getDimensionId)(Actor *this, AutomaticID<Dimension,int> *result);
  bool (__fastcall *canChangeDimensions)(Actor *this);
  void (__fastcall *changeDimension)(Actor *this, const ChangeDimensionPacket *);
  void (__fastcall *changeDimension)(Actor *this, AutomaticID<Dimension,int>, bool);
  ActorUniqueID *(__fastcall *getControllingPlayer)(Actor *this, ActorUniqueID *result);
  void (__fastcall *checkFallDamage)(Actor *this, float, bool);
  void (__fastcall *causeFallDamage)(Actor *this, float);
  void (__fastcall *handleFallDistanceOnServer)(Actor *this, float, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, int, bool);
  void (__fastcall *playSynchronizedSound)(Actor *this, LevelSoundEvent, const Vec3 *, const Block *, bool);
  void (__fastcall *onSynchedDataUpdate)(Actor *this, int);
  bool (__fastcall *canAddRider)(Actor *this, Actor *);
  bool (__fastcall *canPickupItem)(Actor *this, const ItemStack *);
  bool (__fastcall *canBePulledIntoVehicle)(Actor *this);
  bool (__fastcall *inCaravan)(Actor *this);
  bool (__fastcall *isLeashableType)(Actor *this);
  void (__fastcall *tickLeash)(Actor *this);
  void (__fastcall *sendMotionPacketIfNeeded)(Actor *this);
  bool (__fastcall *canSynchronizeNewEntity)(Actor *this);
  bool (__fastcall *stopRiding)(Actor *this, bool, bool, bool, bool);
  void (__fastcall *startSwimming)(Actor *this);
  void (__fastcall *stopSwimming)(Actor *this);
  void (__fastcall *buildDebugInfo)(Actor *this, std::string *);
  CommandPermissionLevel (__fastcall *getCommandPermissionLevel)(Actor *this);
  AttributeInstance *(__fastcall *getMutableAttribute)(Actor *this, const Attribute *);
  const AttributeInstance *(__fastcall *getAttribute)(Actor *this, const Attribute *);
  int (__fastcall *getDeathTime)(Actor *this);
  void (__fastcall *heal)(Actor *this, int);
  bool (__fastcall *isInvertedHealAndHarm)(Actor *this);
  bool (__fastcall *canBeAffected)(Actor *this, const MobEffectInstance *);
  bool (__fastcall *canBeAffected)(Actor *this, int);
  bool (__fastcall *canBeAffectedByArrow)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectAdded)(Actor *this, MobEffectInstance *);
  void (__fastcall *onEffectUpdated)(Actor *this, const MobEffectInstance *);
  void (__fastcall *onEffectRemoved)(Actor *this, MobEffectInstance *);
  AnimationComponent *(__fastcall *getAnimationComponent)(Actor *this);
  void (__fastcall *openContainerComponent)(Actor *this, Player *);
  void (__fastcall *swing)(Actor *this);
  void (__fastcall *useItem)(Actor *this, ItemStackBase *, ItemUseMethod, bool);
  bool (__fastcall *hasOutputSignal)(Actor *this, unsigned __int8);
  int (__fastcall *getOutputSignal)(Actor *this);
  void (__fastcall *getDebugText)(Actor *this, std::vector<std::string> *);
  float (__fastcall *getMapDecorationRotation)(Actor *this);
  float (__fastcall *getRiderYRotation)(Actor *this, const Actor *);
  float (__fastcall *getYHeadRot)(Actor *this);
  bool (__fastcall *isWorldBuilder)(Actor *this);
  bool (__fastcall *isCreative)(Actor *this);
  bool (__fastcall *isAdventure)(Actor *this);
  bool (__fastcall *add)(Actor *this, ItemStack *);
  bool (__fastcall *drop)(Actor *this, const ItemStack *, bool);
  bool (__fastcall *getInteraction)(Actor *this, Player *, ActorInteraction *, const Vec3 *);
  bool (__fastcall *canDestroyBlock)(Actor *this, const Block *);
  void (__fastcall *setAuxValue)(Actor *this, int);
  void (__fastcall *setSize)(Actor *this, float, float);
  int (__fastcall *getLifeSpan)(Actor *this);
  void (__fastcall *onOrphan)(Actor *this);
  void (__fastcall *wobble)(Actor *this);
  bool (__fastcall *wasHurt)(Actor *this);
  void (__fastcall *startSpinAttack)(Actor *this);
  void (__fastcall *stopSpinAttack)(Actor *this);
  void (__fastcall *setDamageNearbyMobs)(Actor *this, bool);
  bool (__fastcall *hasCritBox)(Actor *this);
  bool (__fastcall *isCritHit)(Actor *this);
  void (__fastcall *renderDebugServerState)(Actor *this, const Options *);
  void (__fastcall *reloadLootTable)(Actor *this, const EquipmentTableDefinition *);
  void (__fastcall *reloadLootTable)(Actor *this);
  float (__fastcall *getDeletionDelayTimeSeconds)(Actor *this);
  void (__fastcall *kill)(Actor *this);
  void (__fastcall *die)(Actor *this, const ActorDamageSource *);
  bool (__fastcall *shouldTick)(Actor *this);
  std::shared_ptr<IActorMovementProxy> *(__fastcall *createMovementProxy)(Actor *this, std::shared_ptr<IActorMovementProxy> *result);
  void (__fastcall *updateEntitySpecificMolangVariables)(Actor *this, RenderParams *);
  bool (__fastcall *shouldTryMakeStepSound)(Actor *this);
  float (__fastcall *getNextStep)(Actor *this, const float);
  bool (__fastcall *canMakeStepSound)(Actor *this);
  void (__fastcall *outOfWorld)(Actor *this);
  bool (__fastcall *_hurt)(Actor *this, const ActorDamageSource *, int, bool, bool);
  void (__fastcall *markHurt)(Actor *this);
  void (__fastcall *readAdditionalSaveData)(Actor *this, const CompoundTag *, DataLoadHelper *);
  void (__fastcall *addAdditionalSaveData)(Actor *this, CompoundTag *);
  void (__fastcall *_playStepSound)(Actor *this, const BlockPos *, const Block *);
  void (__fastcall *_playFlySound)(Actor *this, const BlockPos *, const Block *);
  bool (__fastcall *_makeFlySound)(Actor *this);
  void (__fastcall *checkInsideBlocks)(Actor *this, float);
  void (__fastcall *pushOutOfBlocks)(Actor *this, const Vec3 *);
  bool (__fastcall *updateWaterState)(Actor *this);
  void (__fastcall *doWaterSplashEffect)(Actor *this);
  void (__fastcall *spawnTrailBubbles)(Actor *this);
  void (__fastcall *updateInsideBlock)(Actor *this);
  LootTable *(__fastcall *getLootTable)(Actor *this);
  LootTable *(__fastcall *getDefaultLootTable)(Actor *this);
  void (__fastcall *_removeRider)(Actor *this, const ActorUniqueID *, bool, bool, bool);
  void (__fastcall *_onSizeUpdated)(Actor *this);
  void (__fastcall *_doAutoAttackOnTouch)(Actor *this, Actor *);
  void (__fastcall *knockback)(Mob *this, Actor *, int, float, float, float, float, float);
  void (__fastcall *resolveDeathLoot)(Mob *this, int, const ActorDamageSource *);
  void (__fastcall *spawnAnim)(Mob *this);
  void (__fastcall *setSleeping)(Mob *this, bool);
  void (__fastcall *setSprinting)(Mob *this, bool);
  void (__fastcall *playAmbientSound)(Mob *this);
  LevelSoundEvent (__fastcall *getAmbientSound)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicks)(Mob *this);
  int (__fastcall *getAmbientSoundPostponeTicksRange)(Mob *this);
  const TextureUVCoordinateSet *(__fastcall *getItemInHandIcon)(Mob *this, const ItemStack *, int);
  float (__fastcall *getSpeed)(Mob *this);
  void (__fastcall *setSpeed)(Mob *this, float);
  float (__fastcall *getJumpPower)(Mob *this);
  bool (__fastcall *hurtEffects)(Mob *this, const ActorDamageSource *, int, bool, bool);
  int (__fastcall *getMeleeWeaponDamageBonus)(Mob *this, Mob *);
  int (__fastcall *getMeleeKnockbackBonus)(Mob *this);
  void (__fastcall *travel)(Mob *this, IMobMovementProxy *, float, float, float);
  void (__fastcall *travel)(Mob *this, float, float, float);
  void (__fastcall *applyFinalFriction)(Mob *this, float, bool);
  void (__fastcall *updateWalkAnim)(Mob *this);
  void (__fastcall *aiStep)(Mob *this, IMobMovementProxy *);
  void (__fastcall *aiStep)(Mob *this);
  void (__fastcall *pushActors)(Mob *this);
  void (__fastcall *lookAt)(Mob *this, Actor *, float, float);
  bool (__fastcall *isLookingAtAnEntity)(Mob *this);
  bool (__fastcall *checkSpawnRules)(Mob *this, bool);
  bool (__fastcall *checkSpawnObstruction)(Mob *this);
  float (__fastcall *getAttackAnim)(Mob *this, float);
  int (__fastcall *getItemUseDuration)(Mob *this);
  float (__fastcall *getItemUseStartupProgress)(Mob *this);
  float (__fastcall *getItemUseIntervalProgress)(Mob *this);
  int (__fastcall *getItemuseIntervalAxis)(Mob *this);
  int (__fastcall *getTimeAlongSwing)(Mob *this);
  void (__fastcall *ate)(Mob *this);
  float (__fastcall *getMaxHeadXRot)(Mob *this);
  Mob *(__fastcall *getLastHurtByMob)(Mob *this);
  void (__fastcall *setLastHurtByMob)(Mob *this, Mob *);
  Player *(__fastcall *getLastHurtByPlayer)(Mob *this);
  void (__fastcall *setLastHurtByPlayer)(Mob *this, Player *);
  Mob *(__fastcall *getLastHurtMob)(Mob *this);
  void (__fastcall *setLastHurtMob)(Mob *this, Actor *);
  bool (__fastcall *isAlliedTo)(Mob *this, Mob *);
  bool (__fastcall *doHurtTarget)(Mob *this, Actor *);
  bool (__fastcall *canBeControlledByRider)(Mob *this);
  void (__fastcall *leaveCaravan)(Mob *this);
  void (__fastcall *joinCaravan)(Mob *this, Mob *);
  bool (__fastcall *hasCaravanTail)(Mob *this);
  ActorUniqueID *(__fastcall *getCaravanHead)(Mob *this, ActorUniqueID *result);
  int (__fastcall *getArmorValue)(Mob *this);
  float (__fastcall *getArmorCoverPercentage)(Mob *this);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int, const std::bitset<4> *);
  void (__fastcall *hurtArmor)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *hurtArmorSlot)(Mob *this, const ActorDamageSource *, int, ArmorSlot);
  void (__fastcall *setDamagedArmor)(Mob *this, ArmorSlot, const ItemStack *);
  void (__fastcall *sendArmorDamage)(Mob *this, const std::bitset<4> *);
  void (__fastcall *sendArmor)(Mob *this, const std::bitset<4> *);
  void (__fastcall *containerChanged)(Mob *this, int);
  void (__fastcall *updateEquipment)(Mob *this);
  int (__fastcall *clearEquipment)(Mob *this);
  std::vector<ItemStack const *> *(__fastcall *getAllArmor)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<int> *(__fastcall *getAllArmorID)(Mob *this, std::vector<int> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllHand)(Mob *this, std::vector<ItemStack const *> *result);
  std::vector<ItemStack const *> *(__fastcall *getAllEquipment)(Mob *this, std::vector<ItemStack const *> *result);
  int (__fastcall *getArmorTypeHash)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this);
  void (__fastcall *dropEquipmentOnDeath)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *clearVanishEnchantedItemsOnDeath)(Mob *this);
  void (__fastcall *sendInventory)(Mob *this, bool);
  int (__fastcall *getDamageAfterMagicAbsorb)(Mob *this, const ActorDamageSource *, int);
  bool (__fastcall *createAIGoals)(Mob *this);
  void (__fastcall *onBorn)(Mob *this, Actor *, Actor *);
  bool (__fastcall *setItemSlot)(Mob *this, EquipmentSlot, const ItemStack *);
  void (__fastcall *setTransitioningSitting)(Mob *this, bool);
  void (__fastcall *attackAnimation)(Mob *this, Actor *, float);
  int (__fastcall *getAttackTime)(Mob *this);
  float (__fastcall *_getWalkTargetValue)(Mob *this, const BlockPos *);
  bool (__fastcall *canExistWhenDisallowMob)(Mob *this);
  bool (__fastcall *useNewAi)(Mob *this);
  void (__fastcall *ascendLadder)(Mob *this);
  void (__fastcall *ascendScaffolding)(Mob *this);
  void (__fastcall *descendScaffolding)(Mob *this);
  void (__fastcall *dropContainer)(Mob *this);
  std::unique_ptr<BodyControl> *(__fastcall *initBodyControl)(Mob *this, std::unique_ptr<BodyControl> *result);
  void (__fastcall *jumpFromGround)(Mob *this, IMobMovementProxy *);
  void (__fastcall *jumpFromGround)(Mob *this);
  void (__fastcall *updateAi)(Mob *this);
  void (__fastcall *newServerAiStep)(Mob *this);
  void (__fastcall *_serverAiMobStep)(Mob *this);
  int (__fastcall *getDamageAfterEnchantReduction)(Mob *this, const ActorDamageSource *, int);
  int (__fastcall *getDamageAfterArmorAbsorb)(Mob *this, const ActorDamageSource *, int);
  void (__fastcall *dropBags)(Mob *this);
  void (__fastcall *tickDeath)(Mob *this);
  void (__fastcall *updateGliding)(Mob *this);
  bool (__fastcall *_allowAscendingScaffolding)(Mob *this);
};